home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Special 25 / AMIGAplus Sonderheft 25 (2000)(Falke)(DE)(Track 1 of 4)[!].iso / Updates / PowerPC / pdflib / bind / perl / pdflib_pl.c < prev    next >
C/C++ Source or Header  |  2000-05-16  |  73KB  |  2,820 lines
  1. /*
  2.  * FILE : pdflib_pl.c
  3.  * 
  4.  * This file was automatically generated by :
  5.  * Simplified Wrapper and Interface Generator (SWIG)
  6.  * Version 1.2 (alpha 1)
  7.  * 
  8.  * Portions Copyright (c) 1995-1998
  9.  * The University of Utah and The Regents of the University of California.
  10.  * Permission is granted to distribute this file in any manner provided
  11.  * this notice remains intact.
  12.  * 
  13.  * Do not make changes to this file--changes will be lost!
  14.  *
  15.  */
  16.  
  17.  
  18. #define SWIGCODE
  19. /* Implementation : PERL 5 */
  20.  
  21. #define SWIGPERL
  22. #define SWIGPERL5
  23. #ifdef __cplusplus
  24. #include <math.h>
  25. #include <stdlib.h>
  26. extern "C" {
  27. #endif
  28. #include "EXTERN.h"
  29. #include "perl.h"
  30. #include "XSUB.h"
  31. #undef free
  32. #undef malloc
  33. #include <string.h>
  34. #ifdef __cplusplus
  35. }
  36. #endif
  37. /* Definitions for compiling Perl extensions on a variety of machines */
  38.  
  39. #if defined(WIN32) || defined(__WIN32__)
  40. #   if defined(_MSC_VER)
  41. #    define SWIGEXPORT(a,b) __declspec(dllexport) a b
  42. #   else
  43. #    if defined(__BORLANDC__)
  44. #        define SWIGEXPORT(a,b) a _export b
  45. #    else
  46. #        define SWIGEXPORT(a,b) a b
  47. #    endif
  48. #   endif
  49. #else
  50. #   define SWIGEXPORT(a,b) a b
  51. #endif
  52.  
  53. #ifdef PERL_OBJECT
  54. #define MAGIC_PPERL  CPerl *pPerl = (CPerl *) this;
  55. #define MAGIC_CAST   (int (CPerl::*)(SV *, MAGIC *))
  56. #define SWIGCLASS_STATIC 
  57. #else
  58. #define MAGIC_PPERL
  59. #define MAGIC_CAST
  60. #define SWIGCLASS_STATIC static
  61. #endif
  62.  
  63.  
  64. /*****************************************************************************
  65.  * $Header: /usr/local/cvsroot/swig/swig1/swig_lib/perl5/perl5ptr.swg,v 1.1.1.1 1999/01/21 11:16:43 harcoh Exp $
  66.  *
  67.  * perl5ptr.swg
  68.  *
  69.  * This file contains supporting code for the SWIG run-time type checking
  70.  * mechanism.  The following functions are available :
  71.  *
  72.  * SWIG_RegisterMapping(char *origtype, char *newtype, void *(*cast)(void *));
  73.  *
  74.  *      Registers a new type-mapping with the type-checker.  origtype is the
  75.  *      original datatype and newtype is an equivalent type.  cast is optional
  76.  *      pointer to a function to cast pointer values between types (this
  77.  *      is only used to cast pointers from derived classes to base classes in C++)
  78.  *      
  79.  * SWIG_MakePtr(char *buffer, void *ptr, char *typestring);
  80.  *     
  81.  *      Makes a pointer string from a pointer and typestring.  The result is returned
  82.  *      in buffer.
  83.  *
  84.  * char * SWIG_GetPtr(SV *obj, void **ptr, char *type)
  85.  *
  86.  *      Gets a pointer value from a Perl5 scalar value.  If there is a 
  87.  *      type-mismatch, returns a character string to the received type.  
  88.  *      On success, returns NULL.
  89.  *
  90.  *
  91.  * You can remap these functions by making a file called "swigptr.swg" in
  92.  * your the same directory as the interface file you are wrapping.
  93.  *
  94.  * These functions are normally declared static, but this file can be
  95.  * can be used in a multi-module environment by redefining the symbol
  96.  * SWIGSTATIC.
  97.  *
  98.  * $Log: perl5ptr.swg,v $
  99.  * Revision 1.1.1.1  1999/01/21 11:16:43  harcoh
  100.  * import of Swig 1.2a1
  101.  *
  102.  * Revision 1.1  1996/12/26 22:17:29  beazley
  103.  * Initial revision
  104.  *
  105.  *****************************************************************************/
  106.  
  107. #include <stdlib.h>
  108.  
  109. #ifdef SWIG_GLOBAL
  110. #ifdef __cplusplus
  111. #define SWIGSTATIC extern "C"
  112. #else
  113. #define SWIGSTATIC
  114. #endif
  115. #endif
  116.  
  117. #ifndef SWIGSTATIC
  118. #define SWIGSTATIC static
  119. #endif
  120.  
  121. /* These are internal variables.   Should be static */
  122.  
  123. typedef struct SwigPtrType {
  124.   char               *name;
  125.   int                 len;
  126.   void               *(*cast)(void *);
  127.   struct SwigPtrType *next;
  128. } SwigPtrType;
  129.  
  130. /* Pointer cache structure */
  131.  
  132. typedef struct {
  133.   int                 stat;               /* Status (valid) bit             */
  134.   SwigPtrType        *tp;                 /* Pointer to type structure      */
  135.   char                name[256];          /* Given datatype name            */
  136.   char                mapped[256];        /* Equivalent name                */
  137. } SwigCacheType;
  138.  
  139. static int SwigPtrMax  = 64;           /* Max entries that can be currently held */
  140. static int SwigPtrN    = 0;            /* Current number of entries              */
  141. static int SwigPtrSort = 0;            /* Status flag indicating sort            */
  142. static SwigPtrType *SwigPtrTable = 0;  /* Table containing pointer equivalences  */
  143. static int SwigStart[256];             /* Table containing starting positions    */
  144.  
  145. /* Cached values */
  146.  
  147. #define SWIG_CACHESIZE  8
  148. #define SWIG_CACHEMASK  0x7
  149. static SwigCacheType SwigCache[SWIG_CACHESIZE];  
  150. static int SwigCacheIndex = 0;
  151. static int SwigLastCache = 0;
  152.  
  153. /* Sort comparison function */
  154. static int swigsort(const void *data1, const void *data2) {
  155.     SwigPtrType *d1 = (SwigPtrType *) data1;
  156.     SwigPtrType *d2 = (SwigPtrType *) data2;
  157.     return strcmp(d1->name,d2->name);
  158. }
  159.  
  160. /* Binary Search function */
  161. static int swigcmp(const void *key, const void *data) {
  162.   char *k = (char *) key;
  163.   SwigPtrType *d = (SwigPtrType *) data;
  164.   return strncmp(k,d->name,d->len);
  165. }
  166.  
  167. /* Register a new datatype with the type-checker */
  168.  
  169. #ifndef PERL_OBJECT
  170. SWIGSTATIC 
  171. void SWIG_RegisterMapping(char *origtype, char *newtype, void *(*cast)(void *)) {
  172. #else
  173. SWIGSTATIC
  174. #define SWIG_RegisterMapping(a,b,c) _SWIG_RegisterMapping(pPerl, a,b,c)
  175. void _SWIG_RegisterMapping(CPerl *pPerl, char *origtype, char *newtype, void *(*cast)(void *)) {
  176. #endif
  177.  
  178.   int i;
  179.   SwigPtrType *t = 0, *t1;
  180.  
  181.   if (!SwigPtrTable) {     
  182.     SwigPtrTable = (SwigPtrType *) malloc(SwigPtrMax*sizeof(SwigPtrType));
  183.     SwigPtrN = 0;
  184.   }
  185.   if (SwigPtrN >= SwigPtrMax) {
  186.     SwigPtrMax = 2*SwigPtrMax;
  187.     SwigPtrTable = (SwigPtrType *) realloc(SwigPtrTable,SwigPtrMax*sizeof(SwigPtrType));
  188.   }
  189.   for (i = 0; i < SwigPtrN; i++)
  190.     if (strcmp(SwigPtrTable[i].name,origtype) == 0) {
  191.       t = &SwigPtrTable[i];
  192.       break;
  193.     }
  194.   if (!t) {
  195.     t = &SwigPtrTable[SwigPtrN];
  196.     t->name = origtype;
  197.     t->len = strlen(t->name);
  198.     t->cast = 0;
  199.     t->next = 0;
  200.     SwigPtrN++;
  201.   }
  202.   while (t->next) {
  203.     if (strcmp(t->name,newtype) == 0) {
  204.       if (cast) t->cast = cast;
  205.       return;
  206.     }
  207.     t = t->next;
  208.   }
  209.   t1 = (SwigPtrType *) malloc(sizeof(SwigPtrType));
  210.   t1->name = newtype;
  211.   t1->len = strlen(t1->name);
  212.   t1->cast = cast;
  213.   t1->next = 0;
  214.   t->next = t1;
  215.   SwigPtrSort = 0;
  216. }
  217.  
  218. /* Make a pointer value string */
  219.  
  220. SWIGSTATIC 
  221. void SWIG_MakePtr(char *_c, const void *_ptr, char *type) {
  222.   static char _hex[16] =
  223.   {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
  224.    'a', 'b', 'c', 'd', 'e', 'f'};
  225.   unsigned long _p, _s;
  226.   char _result[20], *_r;    /* Note : a 64-bit hex number = 16 digits */
  227.   _r = _result;
  228.   _p = (unsigned long) _ptr;
  229.   if (_p > 0) {
  230.     while (_p > 0) {
  231.       _s = _p & 0xf;
  232.       *(_r++) = _hex[_s];
  233.       _p = _p >> 4;
  234.     }
  235.     *_r = '_';
  236.     while (_r >= _result)
  237.       *(_c++) = *(_r--);
  238.   } else {
  239.     strcpy (_c, "NULL");
  240.   }
  241.   if (_ptr)
  242.     strcpy (_c, type);
  243. }
  244.  
  245. /* Define for backwards compatibility */
  246.  
  247. #define _swig_make_hex   SWIG_MakePtr 
  248.  
  249. /* Function for getting a pointer value */
  250.  
  251. #ifndef PERL_OBJECT
  252. SWIGSTATIC 
  253. char *SWIG_GetPtr(SV *sv, void **ptr, char *_t)
  254. #else
  255. SWIGSTATIC
  256. #define SWIG_GetPtr(a,b,c) _SWIG_GetPtr(pPerl,a,b,c)
  257. char *_SWIG_GetPtr(CPerl *pPerl, SV *sv, void **ptr, char *_t)
  258. #endif
  259. {
  260.   char temp_type[256];
  261.   char *name,*_c;
  262.   int  len,i,start,end;
  263.   IV   tmp;
  264.   SwigPtrType *sp,*tp;
  265.   SwigCacheType *cache;
  266.  
  267.   /* If magical, apply more magic */
  268.  
  269.   if (SvGMAGICAL(sv))
  270.     mg_get(sv);
  271.  
  272.   /* Check to see if this is an object */
  273.   if (sv_isobject(sv)) {
  274.     SV *tsv = (SV*) SvRV(sv);
  275.     if ((SvTYPE(tsv) == SVt_PVHV)) {
  276.       MAGIC *mg;
  277.       if (SvMAGICAL(tsv)) {
  278.     mg = mg_find(tsv,'P');
  279.     if (mg) {
  280.       SV *rsv = mg->mg_obj;
  281.       if (sv_isobject(rsv)) {
  282.         tmp = SvIV((SV*)SvRV(rsv));
  283.       }
  284.     }
  285.       } else {
  286.     return "Not a valid pointer value";
  287.       }
  288.     } else {
  289.       tmp = SvIV((SV*)SvRV(sv));
  290.     }
  291.     if (!_t) {
  292.       *(ptr) = (void *) tmp;
  293.       return (char *) 0;
  294.     }
  295.   } else if (sv == &sv_undef) {            /* Check for undef */
  296.     *(ptr) = (void *) 0;
  297.     return (char *) 0;
  298.   } else if (SvTYPE(sv) == SVt_RV) {       /* Check for NULL pointer */
  299.     *(ptr) = (void *) 0;
  300.     if (!SvROK(sv)) 
  301.       return (char *) 0;
  302.     else
  303.       return "Not a valid pointer value";
  304.   } else {                                 /* Don't know what it is */
  305.       *(ptr) = (void *) 0;
  306.       return "Not a valid pointer value";
  307.   }
  308.   if (_t) {
  309.     /* Now see if the types match */      
  310.  
  311.     if (!sv_isa(sv,_t)) {
  312.       _c = HvNAME(SvSTASH(SvRV(sv)));
  313.       if (!SwigPtrSort) {
  314.     qsort((void *) SwigPtrTable, SwigPtrN, sizeof(SwigPtrType), swigsort);  
  315.     for (i = 0; i < 256; i++) {
  316.       SwigStart[i] = SwigPtrN;
  317.     }
  318.     for (i = SwigPtrN-1; i >= 0; i--) {
  319.       SwigStart[SwigPtrTable[i].name[0]] = i;
  320.     }
  321.     for (i = 255; i >= 1; i--) {
  322.       if (SwigStart[i-1] > SwigStart[i])
  323.         SwigStart[i-1] = SwigStart[i];
  324.     }
  325.     SwigPtrSort = 1;
  326.     for (i = 0; i < SWIG_CACHESIZE; i++)  
  327.       SwigCache[i].stat = 0;
  328.       }
  329.       /* First check cache for matches.  Uses last cache value as starting point */
  330.       cache = &SwigCache[SwigLastCache];
  331.       for (i = 0; i < SWIG_CACHESIZE; i++) {
  332.     if (cache->stat) {
  333.       if (strcmp(_t,cache->name) == 0) {
  334.         if (strcmp(_c,cache->mapped) == 0) {
  335.           cache->stat++;
  336.           *ptr = (void *) tmp;
  337.           if (cache->tp->cast) *ptr = (*(cache->tp->cast))(*ptr);
  338.           return (char *) 0;
  339.         }
  340.       }
  341.     }
  342.     SwigLastCache = (SwigLastCache+1) & SWIG_CACHEMASK;
  343.     if (!SwigLastCache) cache = SwigCache;
  344.     else cache++;
  345.       }
  346.  
  347.       start = SwigStart[_t[0]];
  348.       end = SwigStart[_t[0]+1];
  349.       sp = &SwigPtrTable[start];
  350.       while (start < end) {
  351.     if (swigcmp(_t,sp) == 0) break;
  352.     sp++;
  353.     start++;
  354.       }
  355.       if (start >= end) sp = 0;
  356.       if (sp) {
  357.     while (swigcmp(_t,sp) == 0) {
  358.       name = sp->name;
  359.       len = sp->len;
  360.       tp = sp->next;
  361.       while(tp) {
  362.         if (tp->len >= 255) {
  363.           return _c;
  364.         }
  365.         strcpy(temp_type,tp->name);
  366.         strncat(temp_type,_t+len,255-tp->len);
  367.         if (sv_isa(sv,temp_type)) {
  368.           /* Get pointer value */
  369.           *ptr = (void *) tmp;
  370.           if (tp->cast) *ptr = (*(tp->cast))(*ptr);
  371.  
  372.           strcpy(SwigCache[SwigCacheIndex].mapped,_c);
  373.           strcpy(SwigCache[SwigCacheIndex].name,_t);
  374.           SwigCache[SwigCacheIndex].stat = 1;
  375.           SwigCache[SwigCacheIndex].tp = tp;
  376.           SwigCacheIndex = SwigCacheIndex & SWIG_CACHEMASK;
  377.           return (char *) 0;
  378.         }
  379.         tp = tp->next;
  380.       } 
  381.       /* Hmmm. Didn't find it this time */
  382.        sp++;
  383.     }
  384.       }
  385.       /* Didn't find any sort of match for this data.  
  386.      Get the pointer value and return the received type */
  387.       *ptr = (void *) tmp;
  388.       return _c;
  389.     } else {
  390.       /* Found a match on the first try.  Return pointer value */
  391.       *ptr = (void *) tmp;
  392.       return (char *) 0;
  393.     }
  394.   } 
  395.   *ptr = (void *) tmp;
  396.   return (char *) 0;
  397. }
  398.  
  399. /* Compatibility mode */
  400.  
  401. #define _swig_get_hex  SWIG_GetPtr
  402. /* Magic variable code */
  403. #ifndef PERL_OBJECT
  404. #define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
  405. static void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) {
  406. #else
  407. #define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
  408. static void _swig_create_magic(CPerl *pPerl, SV *sv, char *name, int (CPerl::*set)(SV *, MAGIC *), int (CPerl::*get)(SV *, MAGIC *)) {
  409. #endif
  410.   MAGIC *mg;
  411.   sv_magic(sv,sv,'U',name,strlen(name));
  412.   mg = mg_find(sv,'U');
  413.   mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
  414.   mg->mg_virtual->svt_get = get;
  415.   mg->mg_virtual->svt_set = set;
  416.   mg->mg_virtual->svt_len = 0;
  417.   mg->mg_virtual->svt_clear = 0;
  418.   mg->mg_virtual->svt_free = 0;
  419. }
  420.  
  421. #define SWIG_init    boot_pdflib
  422.  
  423. #define SWIG_name   "pdflibc::boot_pdflib"
  424. #define SWIG_varinit "pdflibc::var_pdflib_init();"
  425. #ifdef __cplusplus
  426. extern "C"
  427. #endif
  428. #ifndef PERL_OBJECT
  429. SWIGEXPORT(void,boot_pdflib)(CV* cv);
  430. #else
  431. SWIGEXPORT(void,boot_pdflib)(CV *cv, CPerlObj *pPerl);
  432. #endif
  433.  
  434. #define  SWIG_MemoryError    1
  435. #define  SWIG_IOError        2
  436. #define  SWIG_RuntimeError   3
  437. #define  SWIG_IndexError     4
  438. #define  SWIG_TypeError      5
  439. #define  SWIG_DivisionByZero 6
  440. #define  SWIG_OverflowError  7
  441. #define  SWIG_SyntaxError    8
  442. #define  SWIG_ValueError     9
  443. #define  SWIG_SystemError   10
  444. #define  SWIG_UnknownError  99
  445.  
  446. #define SWIG_exception(a,b)   croak(b)
  447.  
  448. #include <setjmp.h>
  449.  
  450. /* The following sick stuff is an attempt to make recent Perl versions
  451.  * work with recent SWIG versions compiled with recent MS VC++ versions.
  452.  */
  453. #ifdef _MSC_VER
  454.     #undef setjmp
  455.     #define setjmp _setjmp
  456.     #undef longjmp
  457. #endif
  458.  
  459. #include "pdflib.h"
  460.  
  461. /* Map PDFlib errors to SWIG exceptions */
  462. static const int pdf_swig_exceptions[] = {
  463.     0,
  464.     SWIG_MemoryError,    /* PDF_MemoryError    1 */
  465.     SWIG_IOError,    /* PDF_IOError        2 */
  466.     SWIG_RuntimeError,    /* PDF_RuntimeError   3 */
  467.     SWIG_IndexError,    /* PDF_IndexError     4 */
  468.     SWIG_TypeError,    /* PDF_TypeError      5 */
  469.     SWIG_DivisionByZero,/* PDF_DivisionByZero 6 */
  470.     SWIG_OverflowError,    /* PDF_OverflowError  7 */
  471.     SWIG_SyntaxError,    /* PDF_SyntaxError    8 */
  472.     SWIG_ValueError,    /* PDF_ValueError     9 */
  473.     SWIG_SystemError,    /* PDF_SystemError   10 */
  474.     SWIG_UnknownError,    /* PDF_NonfatalError 11 */ /* PDFlib-special */
  475.     SWIG_UnknownError,    /* PDF_UnknownError  12 */
  476. };
  477.  
  478. /* SWIG exception handling is currently not thread-safe! */
  479. static jmp_buf        exception_buffer;
  480. static int        exception_status;
  481. static char        error_message[256];
  482.  
  483. /* Exception handling for SWIG. Note that these are not used for the C API */
  484. #define try        if ((exception_status = setjmp(exception_buffer)) == 0)
  485. #define catch(error)    else if (exception_status == error)
  486. #define throw(error)    longjmp(exception_buffer, error)
  487. #define finally        else
  488.  
  489. /* PDFlib error handler for the SWIG libraries */
  490.  
  491. static void
  492. pdf_swig_errorhandler(PDF *p, int type, const char* shortmsg)
  493. {
  494.     sprintf(error_message, "PDFlib: %s\n", shortmsg);
  495.  
  496.     /* Issue a warning message and continue for non-fatal errors */
  497.     if (type == PDF_NonfatalError) {
  498.     fprintf(stderr, error_message);
  499.     return;
  500.     }
  501.     
  502.     /* Clean up PDFlib internals and delete p in all other cases */
  503.     if (p != NULL)
  504.     PDF_delete(p);
  505.  
  506.     /* ...and throw an exception */
  507.     throw(type);
  508. }
  509.  
  510. /* Force the SWIG error handler for all clients */
  511. #define PDF_new() PDF_new2(pdf_swig_errorhandler, NULL, NULL, NULL, NULL)
  512.  
  513. /* export the PDFlib routines to the shared library */
  514. #ifdef __MWERKS__
  515. #pragma export on
  516. #endif
  517.  
  518. #ifdef PERL_OBJECT
  519. #define MAGIC_CLASS _wrap_pdflib_var::
  520. class _wrap_pdflib_var : public CPerl {
  521. public:
  522. #else
  523. #define MAGIC_CLASS
  524. #endif
  525. SWIGCLASS_STATIC int swig_magic_readonly(SV *sv, MAGIC *mg) {
  526.     MAGIC_PPERL
  527.     sv = sv; mg = mg;
  528.     croak("Value is read-only.");
  529.     return 0;
  530. }
  531.  
  532.  
  533. #ifdef PERL_OBJECT
  534. };
  535. #endif
  536.  
  537. XS(_wrap_PDF_boot) {
  538.  
  539.     int argvi = 0;
  540.     dXSARGS ;
  541.  
  542.     cv = cv;
  543.     if ((items < 0) || (items > 0)) 
  544.         croak("Usage: PDF_boot();");
  545. {
  546.     try {     PDF_boot();
  547.  }
  548.     else {
  549.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  550.     }
  551. }    XSRETURN(argvi);
  552. }
  553.  
  554. XS(_wrap_PDF_shutdown) {
  555.  
  556.     int argvi = 0;
  557.     dXSARGS ;
  558.  
  559.     cv = cv;
  560.     if ((items < 0) || (items > 0)) 
  561.         croak("Usage: PDF_shutdown();");
  562. {
  563.     try {     PDF_shutdown();
  564.  }
  565.     else {
  566.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  567.     }
  568. }    XSRETURN(argvi);
  569. }
  570.  
  571. XS(_wrap_PDF_new) {
  572.  
  573.     PDF * _result;
  574.     int argvi = 0;
  575.     dXSARGS ;
  576.  
  577.     cv = cv;
  578.     if ((items < 0) || (items > 0)) 
  579.         croak("Usage: PDF_new();");
  580. {
  581.     try {     _result = (PDF *)PDF_new();
  582.  }
  583.     else {
  584.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  585.     }
  586. }    ST(argvi) = sv_newmortal();
  587.     sv_setref_pv(ST(argvi++),"PDFPtr", (void *) _result);
  588.     XSRETURN(argvi);
  589. }
  590.  
  591. XS(_wrap_PDF_delete) {
  592.  
  593.     PDF * _arg0;
  594.     int argvi = 0;
  595.     dXSARGS ;
  596.  
  597.     cv = cv;
  598.     if ((items < 1) || (items > 1)) 
  599.         croak("Usage: PDF_delete(p);");
  600.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  601.         croak("Type error in argument 1 of PDF_delete. Expected PDFPtr.");
  602.         XSRETURN(1);
  603.     }
  604. {
  605.     try {     PDF_delete(_arg0);
  606.  }
  607.     else {
  608.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  609.     }
  610. }    XSRETURN(argvi);
  611. }
  612.  
  613. XS(_wrap_PDF_open_file) {
  614.  
  615.     int  _result;
  616.     PDF * _arg0;
  617.     char * _arg1;
  618.     int argvi = 0;
  619.     dXSARGS ;
  620.  
  621.     cv = cv;
  622.     if ((items < 2) || (items > 2)) 
  623.         croak("Usage: PDF_open_file(p,filename);");
  624.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  625.         croak("Type error in argument 1 of PDF_open_file. Expected PDFPtr.");
  626.         XSRETURN(1);
  627.     }
  628.     _arg1 = (char *) SvPV(ST(1),na);
  629. {
  630.     try {     _result = (int )PDF_open_file(_arg0,_arg1);
  631.  }
  632.     else {
  633.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  634.     }
  635. }    ST(argvi) = sv_newmortal();
  636.     sv_setiv(ST(argvi++),(IV) _result);
  637.     XSRETURN(argvi);
  638. }
  639.  
  640. XS(_wrap_PDF_close) {
  641.  
  642.     PDF * _arg0;
  643.     int argvi = 0;
  644.     dXSARGS ;
  645.  
  646.     cv = cv;
  647.     if ((items < 1) || (items > 1)) 
  648.         croak("Usage: PDF_close(p);");
  649.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  650.         croak("Type error in argument 1 of PDF_close. Expected PDFPtr.");
  651.         XSRETURN(1);
  652.     }
  653. {
  654.     try {     PDF_close(_arg0);
  655.  }
  656.     else {
  657.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  658.     }
  659. }    XSRETURN(argvi);
  660. }
  661.  
  662. XS(_wrap_PDF_begin_page) {
  663.  
  664.     PDF * _arg0;
  665.     float  _arg1;
  666.     float  _arg2;
  667.     int argvi = 0;
  668.     dXSARGS ;
  669.  
  670.     cv = cv;
  671.     if ((items < 3) || (items > 3)) 
  672.         croak("Usage: PDF_begin_page(p,width,height);");
  673.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  674.         croak("Type error in argument 1 of PDF_begin_page. Expected PDFPtr.");
  675.         XSRETURN(1);
  676.     }
  677.     _arg1 = (float ) SvNV(ST(1));
  678.     _arg2 = (float ) SvNV(ST(2));
  679. {
  680.     try {     PDF_begin_page(_arg0,_arg1,_arg2);
  681.  }
  682.     else {
  683.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  684.     }
  685. }    XSRETURN(argvi);
  686. }
  687.  
  688. XS(_wrap_PDF_end_page) {
  689.  
  690.     PDF * _arg0;
  691.     int argvi = 0;
  692.     dXSARGS ;
  693.  
  694.     cv = cv;
  695.     if ((items < 1) || (items > 1)) 
  696.         croak("Usage: PDF_end_page(p);");
  697.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  698.         croak("Type error in argument 1 of PDF_end_page. Expected PDFPtr.");
  699.         XSRETURN(1);
  700.     }
  701. {
  702.     try {     PDF_end_page(_arg0);
  703.  }
  704.     else {
  705.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  706.     }
  707. }    XSRETURN(argvi);
  708. }
  709.  
  710. XS(_wrap_PDF_set_parameter) {
  711.  
  712.     PDF * _arg0;
  713.     char * _arg1;
  714.     char * _arg2;
  715.     int argvi = 0;
  716.     dXSARGS ;
  717.  
  718.     cv = cv;
  719.     if ((items < 3) || (items > 3)) 
  720.         croak("Usage: PDF_set_parameter(p,key,value);");
  721.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  722.         croak("Type error in argument 1 of PDF_set_parameter. Expected PDFPtr.");
  723.         XSRETURN(1);
  724.     }
  725.     _arg1 = (char *) SvPV(ST(1),na);
  726.     _arg2 = (char *) SvPV(ST(2),na);
  727. {
  728.     try {     PDF_set_parameter(_arg0,_arg1,_arg2);
  729.  }
  730.     else {
  731.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  732.     }
  733. }    XSRETURN(argvi);
  734. }
  735.  
  736. XS(_wrap_PDF_findfont) {
  737.  
  738.     int  _result;
  739.     PDF * _arg0;
  740.     char * _arg1;
  741.     char * _arg2;
  742.     int  _arg3;
  743.     int argvi = 0;
  744.     dXSARGS ;
  745.  
  746.     cv = cv;
  747.     if ((items < 4) || (items > 4)) 
  748.         croak("Usage: PDF_findfont(p,fontname,encoding,embed);");
  749.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  750.         croak("Type error in argument 1 of PDF_findfont. Expected PDFPtr.");
  751.         XSRETURN(1);
  752.     }
  753.     _arg1 = (char *) SvPV(ST(1),na);
  754.     _arg2 = (char *) SvPV(ST(2),na);
  755.     _arg3 = (int )SvIV(ST(3));
  756. {
  757.     try {     _result = (int )PDF_findfont(_arg0,_arg1,_arg2,_arg3);
  758.  }
  759.     else {
  760.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  761.     }
  762. }    ST(argvi) = sv_newmortal();
  763.     sv_setiv(ST(argvi++),(IV) _result);
  764.     XSRETURN(argvi);
  765. }
  766.  
  767. XS(_wrap_PDF_setfont) {
  768.  
  769.     PDF * _arg0;
  770.     int  _arg1;
  771.     float  _arg2;
  772.     int argvi = 0;
  773.     dXSARGS ;
  774.  
  775.     cv = cv;
  776.     if ((items < 3) || (items > 3)) 
  777.         croak("Usage: PDF_setfont(p,font,fontsize);");
  778.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  779.         croak("Type error in argument 1 of PDF_setfont. Expected PDFPtr.");
  780.         XSRETURN(1);
  781.     }
  782.     _arg1 = (int )SvIV(ST(1));
  783.     _arg2 = (float ) SvNV(ST(2));
  784. {
  785.     try {     PDF_setfont(_arg0,_arg1,_arg2);
  786.  }
  787.     else {
  788.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  789.     }
  790. }    XSRETURN(argvi);
  791. }
  792.  
  793. XS(_wrap_PDF_set_font) {
  794.  
  795.     PDF * _arg0;
  796.     char * _arg1;
  797.     float  _arg2;
  798.     char * _arg3;
  799.     int argvi = 0;
  800.     dXSARGS ;
  801.  
  802.     cv = cv;
  803.     if ((items < 4) || (items > 4)) 
  804.         croak("Usage: PDF_set_font(p,fontname,fontsize,encoding);");
  805.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  806.         croak("Type error in argument 1 of PDF_set_font. Expected PDFPtr.");
  807.         XSRETURN(1);
  808.     }
  809.     _arg1 = (char *) SvPV(ST(1),na);
  810.     _arg2 = (float ) SvNV(ST(2));
  811.     _arg3 = (char *) SvPV(ST(3),na);
  812. {
  813.     try {     PDF_set_font(_arg0,_arg1,_arg2,_arg3);
  814.  }
  815.     else {
  816.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  817.     }
  818. }    XSRETURN(argvi);
  819. }
  820.  
  821. XS(_wrap_PDF_get_fontname) {
  822.  
  823.     char * _result;
  824.     PDF * _arg0;
  825.     int argvi = 0;
  826.     dXSARGS ;
  827.  
  828.     cv = cv;
  829.     if ((items < 1) || (items > 1)) 
  830.         croak("Usage: PDF_get_fontname(p);");
  831.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  832.         croak("Type error in argument 1 of PDF_get_fontname. Expected PDFPtr.");
  833.         XSRETURN(1);
  834.     }
  835. {
  836.     try {     _result = (char *)PDF_get_fontname(_arg0);
  837.  }
  838.     else {
  839.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  840.     }
  841. }    ST(argvi) = sv_newmortal();
  842.     sv_setpv((SV*)ST(argvi++),(char *) _result);
  843.     XSRETURN(argvi);
  844. }
  845.  
  846. XS(_wrap_PDF_get_fontsize) {
  847.  
  848.     float  _result;
  849.     PDF * _arg0;
  850.     int argvi = 0;
  851.     dXSARGS ;
  852.  
  853.     cv = cv;
  854.     if ((items < 1) || (items > 1)) 
  855.         croak("Usage: PDF_get_fontsize(p);");
  856.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  857.         croak("Type error in argument 1 of PDF_get_fontsize. Expected PDFPtr.");
  858.         XSRETURN(1);
  859.     }
  860. {
  861.     try {     _result = (float )PDF_get_fontsize(_arg0);
  862.  }
  863.     else {
  864.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  865.     }
  866. }    ST(argvi) = sv_newmortal();
  867.     sv_setnv(ST(argvi++), (double) _result);
  868.     XSRETURN(argvi);
  869. }
  870.  
  871. XS(_wrap_PDF_get_font) {
  872.  
  873.     int  _result;
  874.     PDF * _arg0;
  875.     int argvi = 0;
  876.     dXSARGS ;
  877.  
  878.     cv = cv;
  879.     if ((items < 1) || (items > 1)) 
  880.         croak("Usage: PDF_get_font(p);");
  881.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  882.         croak("Type error in argument 1 of PDF_get_font. Expected PDFPtr.");
  883.         XSRETURN(1);
  884.     }
  885. {
  886.     try {     _result = (int )PDF_get_font(_arg0);
  887.  }
  888.     else {
  889.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  890.     }
  891. }    ST(argvi) = sv_newmortal();
  892.     sv_setiv(ST(argvi++),(IV) _result);
  893.     XSRETURN(argvi);
  894. }
  895.  
  896. XS(_wrap_PDF_show) {
  897.  
  898.     PDF * _arg0;
  899.     char * _arg1;
  900.     int argvi = 0;
  901.     dXSARGS ;
  902.  
  903.     cv = cv;
  904.     if ((items < 2) || (items > 2)) 
  905.         croak("Usage: PDF_show(p,text);");
  906.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  907.         croak("Type error in argument 1 of PDF_show. Expected PDFPtr.");
  908.         XSRETURN(1);
  909.     }
  910.     _arg1 = (char *) SvPV(ST(1),na);
  911. {
  912.     try {     PDF_show(_arg0,_arg1);
  913.  }
  914.     else {
  915.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  916.     }
  917. }    XSRETURN(argvi);
  918. }
  919.  
  920. XS(_wrap_PDF_show_xy) {
  921.  
  922.     PDF * _arg0;
  923.     char * _arg1;
  924.     float  _arg2;
  925.     float  _arg3;
  926.     int argvi = 0;
  927.     dXSARGS ;
  928.  
  929.     cv = cv;
  930.     if ((items < 4) || (items > 4)) 
  931.         croak("Usage: PDF_show_xy(p,text,x,y);");
  932.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  933.         croak("Type error in argument 1 of PDF_show_xy. Expected PDFPtr.");
  934.         XSRETURN(1);
  935.     }
  936.     _arg1 = (char *) SvPV(ST(1),na);
  937.     _arg2 = (float ) SvNV(ST(2));
  938.     _arg3 = (float ) SvNV(ST(3));
  939. {
  940.     try {     PDF_show_xy(_arg0,_arg1,_arg2,_arg3);
  941.  }
  942.     else {
  943.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  944.     }
  945. }    XSRETURN(argvi);
  946. }
  947.  
  948. XS(_wrap_PDF_continue_text) {
  949.  
  950.     PDF * _arg0;
  951.     char * _arg1;
  952.     int argvi = 0;
  953.     dXSARGS ;
  954.  
  955.     cv = cv;
  956.     if ((items < 2) || (items > 2)) 
  957.         croak("Usage: PDF_continue_text(p,text);");
  958.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  959.         croak("Type error in argument 1 of PDF_continue_text. Expected PDFPtr.");
  960.         XSRETURN(1);
  961.     }
  962.     _arg1 = (char *) SvPV(ST(1),na);
  963. {
  964.     try {     PDF_continue_text(_arg0,_arg1);
  965.  }
  966.     else {
  967.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  968.     }
  969. }    XSRETURN(argvi);
  970. }
  971.  
  972. XS(_wrap_PDF_set_leading) {
  973.  
  974.     PDF * _arg0;
  975.     float  _arg1;
  976.     int argvi = 0;
  977.     dXSARGS ;
  978.  
  979.     cv = cv;
  980.     if ((items < 2) || (items > 2)) 
  981.         croak("Usage: PDF_set_leading(p,leading);");
  982.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  983.         croak("Type error in argument 1 of PDF_set_leading. Expected PDFPtr.");
  984.         XSRETURN(1);
  985.     }
  986.     _arg1 = (float ) SvNV(ST(1));
  987. {
  988.     try {     PDF_set_leading(_arg0,_arg1);
  989.  }
  990.     else {
  991.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  992.     }
  993. }    XSRETURN(argvi);
  994. }
  995.  
  996. XS(_wrap_PDF_set_text_rise) {
  997.  
  998.     PDF * _arg0;
  999.     float  _arg1;
  1000.     int argvi = 0;
  1001.     dXSARGS ;
  1002.  
  1003.     cv = cv;
  1004.     if ((items < 2) || (items > 2)) 
  1005.         croak("Usage: PDF_set_text_rise(p,rise);");
  1006.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1007.         croak("Type error in argument 1 of PDF_set_text_rise. Expected PDFPtr.");
  1008.         XSRETURN(1);
  1009.     }
  1010.     _arg1 = (float ) SvNV(ST(1));
  1011. {
  1012.     try {     PDF_set_text_rise(_arg0,_arg1);
  1013.  }
  1014.     else {
  1015.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1016.     }
  1017. }    XSRETURN(argvi);
  1018. }
  1019.  
  1020. XS(_wrap_PDF_set_horiz_scaling) {
  1021.  
  1022.     PDF * _arg0;
  1023.     float  _arg1;
  1024.     int argvi = 0;
  1025.     dXSARGS ;
  1026.  
  1027.     cv = cv;
  1028.     if ((items < 2) || (items > 2)) 
  1029.         croak("Usage: PDF_set_horiz_scaling(p,scale);");
  1030.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1031.         croak("Type error in argument 1 of PDF_set_horiz_scaling. Expected PDFPtr.");
  1032.         XSRETURN(1);
  1033.     }
  1034.     _arg1 = (float ) SvNV(ST(1));
  1035. {
  1036.     try {     PDF_set_horiz_scaling(_arg0,_arg1);
  1037.  }
  1038.     else {
  1039.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1040.     }
  1041. }    XSRETURN(argvi);
  1042. }
  1043.  
  1044. XS(_wrap_PDF_set_text_rendering) {
  1045.  
  1046.     PDF * _arg0;
  1047.     int  _arg1;
  1048.     int argvi = 0;
  1049.     dXSARGS ;
  1050.  
  1051.     cv = cv;
  1052.     if ((items < 2) || (items > 2)) 
  1053.         croak("Usage: PDF_set_text_rendering(p,mode);");
  1054.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1055.         croak("Type error in argument 1 of PDF_set_text_rendering. Expected PDFPtr.");
  1056.         XSRETURN(1);
  1057.     }
  1058.     _arg1 = (int )SvIV(ST(1));
  1059. {
  1060.     try {     PDF_set_text_rendering(_arg0,_arg1);
  1061.  }
  1062.     else {
  1063.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1064.     }
  1065. }    XSRETURN(argvi);
  1066. }
  1067.  
  1068. XS(_wrap_PDF_set_text_matrix) {
  1069.  
  1070.     PDF * _arg0;
  1071.     float  _arg1;
  1072.     float  _arg2;
  1073.     float  _arg3;
  1074.     float  _arg4;
  1075.     float  _arg5;
  1076.     float  _arg6;
  1077.     int argvi = 0;
  1078.     dXSARGS ;
  1079.  
  1080.     cv = cv;
  1081.     if ((items < 7) || (items > 7)) 
  1082.         croak("Usage: PDF_set_text_matrix(p,a,b,c,d,e,f);");
  1083.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1084.         croak("Type error in argument 1 of PDF_set_text_matrix. Expected PDFPtr.");
  1085.         XSRETURN(1);
  1086.     }
  1087.     _arg1 = (float ) SvNV(ST(1));
  1088.     _arg2 = (float ) SvNV(ST(2));
  1089.     _arg3 = (float ) SvNV(ST(3));
  1090.     _arg4 = (float ) SvNV(ST(4));
  1091.     _arg5 = (float ) SvNV(ST(5));
  1092.     _arg6 = (float ) SvNV(ST(6));
  1093. {
  1094.     try {     PDF_set_text_matrix(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6);
  1095.  }
  1096.     else {
  1097.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1098.     }
  1099. }    XSRETURN(argvi);
  1100. }
  1101.  
  1102. XS(_wrap_PDF_set_text_pos) {
  1103.  
  1104.     PDF * _arg0;
  1105.     float  _arg1;
  1106.     float  _arg2;
  1107.     int argvi = 0;
  1108.     dXSARGS ;
  1109.  
  1110.     cv = cv;
  1111.     if ((items < 3) || (items > 3)) 
  1112.         croak("Usage: PDF_set_text_pos(p,x,y);");
  1113.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1114.         croak("Type error in argument 1 of PDF_set_text_pos. Expected PDFPtr.");
  1115.         XSRETURN(1);
  1116.     }
  1117.     _arg1 = (float ) SvNV(ST(1));
  1118.     _arg2 = (float ) SvNV(ST(2));
  1119. {
  1120.     try {     PDF_set_text_pos(_arg0,_arg1,_arg2);
  1121.  }
  1122.     else {
  1123.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1124.     }
  1125. }    XSRETURN(argvi);
  1126. }
  1127.  
  1128. XS(_wrap_PDF_set_char_spacing) {
  1129.  
  1130.     PDF * _arg0;
  1131.     float  _arg1;
  1132.     int argvi = 0;
  1133.     dXSARGS ;
  1134.  
  1135.     cv = cv;
  1136.     if ((items < 2) || (items > 2)) 
  1137.         croak("Usage: PDF_set_char_spacing(p,spacing);");
  1138.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1139.         croak("Type error in argument 1 of PDF_set_char_spacing. Expected PDFPtr.");
  1140.         XSRETURN(1);
  1141.     }
  1142.     _arg1 = (float ) SvNV(ST(1));
  1143. {
  1144.     try {     PDF_set_char_spacing(_arg0,_arg1);
  1145.  }
  1146.     else {
  1147.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1148.     }
  1149. }    XSRETURN(argvi);
  1150. }
  1151.  
  1152. XS(_wrap_PDF_set_word_spacing) {
  1153.  
  1154.     PDF * _arg0;
  1155.     float  _arg1;
  1156.     int argvi = 0;
  1157.     dXSARGS ;
  1158.  
  1159.     cv = cv;
  1160.     if ((items < 2) || (items > 2)) 
  1161.         croak("Usage: PDF_set_word_spacing(p,spacing);");
  1162.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1163.         croak("Type error in argument 1 of PDF_set_word_spacing. Expected PDFPtr.");
  1164.         XSRETURN(1);
  1165.     }
  1166.     _arg1 = (float ) SvNV(ST(1));
  1167. {
  1168.     try {     PDF_set_word_spacing(_arg0,_arg1);
  1169.  }
  1170.     else {
  1171.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1172.     }
  1173. }    XSRETURN(argvi);
  1174. }
  1175.  
  1176. XS(_wrap_PDF_stringwidth) {
  1177.  
  1178.     float  _result;
  1179.     PDF * _arg0;
  1180.     char * _arg1;
  1181.     int  _arg2;
  1182.     float  _arg3;
  1183.     int argvi = 0;
  1184.     dXSARGS ;
  1185.  
  1186.     cv = cv;
  1187.     if ((items < 4) || (items > 4)) 
  1188.         croak("Usage: PDF_stringwidth(p,text,font,size);");
  1189.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1190.         croak("Type error in argument 1 of PDF_stringwidth. Expected PDFPtr.");
  1191.         XSRETURN(1);
  1192.     }
  1193.     _arg1 = (char *) SvPV(ST(1),na);
  1194.     _arg2 = (int )SvIV(ST(2));
  1195.     _arg3 = (float ) SvNV(ST(3));
  1196. {
  1197.     try {     _result = (float )PDF_stringwidth(_arg0,_arg1,_arg2,_arg3);
  1198.  }
  1199.     else {
  1200.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1201.     }
  1202. }    ST(argvi) = sv_newmortal();
  1203.     sv_setnv(ST(argvi++), (double) _result);
  1204.     XSRETURN(argvi);
  1205. }
  1206.  
  1207. XS(_wrap_PDF_setdash) {
  1208.  
  1209.     PDF * _arg0;
  1210.     float  _arg1;
  1211.     float  _arg2;
  1212.     int argvi = 0;
  1213.     dXSARGS ;
  1214.  
  1215.     cv = cv;
  1216.     if ((items < 3) || (items > 3)) 
  1217.         croak("Usage: PDF_setdash(p,b,w);");
  1218.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1219.         croak("Type error in argument 1 of PDF_setdash. Expected PDFPtr.");
  1220.         XSRETURN(1);
  1221.     }
  1222.     _arg1 = (float ) SvNV(ST(1));
  1223.     _arg2 = (float ) SvNV(ST(2));
  1224. {
  1225.     try {     PDF_setdash(_arg0,_arg1,_arg2);
  1226.  }
  1227.     else {
  1228.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1229.     }
  1230. }    XSRETURN(argvi);
  1231. }
  1232.  
  1233. XS(_wrap_PDF_setpolydash) {
  1234.  
  1235.     PDF * _arg0;
  1236.     float * _arg1;
  1237.     int  _arg2;
  1238.     int argvi = 0;
  1239.     dXSARGS ;
  1240.  
  1241.     cv = cv;
  1242.     if ((items < 3) || (items > 3)) 
  1243.         croak("Usage: PDF_setpolydash(p,darray,length);");
  1244.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1245.         croak("Type error in argument 1 of PDF_setpolydash. Expected PDFPtr.");
  1246.         XSRETURN(1);
  1247.     }
  1248.     if (SWIG_GetPtr(ST(1),(void **) &_arg1,"floatPtr")) {
  1249.         croak("Type error in argument 2 of PDF_setpolydash. Expected floatPtr.");
  1250.         XSRETURN(1);
  1251.     }
  1252.     _arg2 = (int )SvIV(ST(2));
  1253. {
  1254.     try {     PDF_setpolydash(_arg0,_arg1,_arg2);
  1255.  }
  1256.     else {
  1257.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1258.     }
  1259. }    XSRETURN(argvi);
  1260. }
  1261.  
  1262. XS(_wrap_PDF_setflat) {
  1263.  
  1264.     PDF * _arg0;
  1265.     float  _arg1;
  1266.     int argvi = 0;
  1267.     dXSARGS ;
  1268.  
  1269.     cv = cv;
  1270.     if ((items < 2) || (items > 2)) 
  1271.         croak("Usage: PDF_setflat(p,flatness);");
  1272.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1273.         croak("Type error in argument 1 of PDF_setflat. Expected PDFPtr.");
  1274.         XSRETURN(1);
  1275.     }
  1276.     _arg1 = (float ) SvNV(ST(1));
  1277. {
  1278.     try {     PDF_setflat(_arg0,_arg1);
  1279.  }
  1280.     else {
  1281.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1282.     }
  1283. }    XSRETURN(argvi);
  1284. }
  1285.  
  1286. XS(_wrap_PDF_setlinejoin) {
  1287.  
  1288.     PDF * _arg0;
  1289.     int  _arg1;
  1290.     int argvi = 0;
  1291.     dXSARGS ;
  1292.  
  1293.     cv = cv;
  1294.     if ((items < 2) || (items > 2)) 
  1295.         croak("Usage: PDF_setlinejoin(p,linejoin);");
  1296.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1297.         croak("Type error in argument 1 of PDF_setlinejoin. Expected PDFPtr.");
  1298.         XSRETURN(1);
  1299.     }
  1300.     _arg1 = (int )SvIV(ST(1));
  1301. {
  1302.     try {     PDF_setlinejoin(_arg0,_arg1);
  1303.  }
  1304.     else {
  1305.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1306.     }
  1307. }    XSRETURN(argvi);
  1308. }
  1309.  
  1310. XS(_wrap_PDF_setlinecap) {
  1311.  
  1312.     PDF * _arg0;
  1313.     int  _arg1;
  1314.     int argvi = 0;
  1315.     dXSARGS ;
  1316.  
  1317.     cv = cv;
  1318.     if ((items < 2) || (items > 2)) 
  1319.         croak("Usage: PDF_setlinecap(p,linecap);");
  1320.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1321.         croak("Type error in argument 1 of PDF_setlinecap. Expected PDFPtr.");
  1322.         XSRETURN(1);
  1323.     }
  1324.     _arg1 = (int )SvIV(ST(1));
  1325. {
  1326.     try {     PDF_setlinecap(_arg0,_arg1);
  1327.  }
  1328.     else {
  1329.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1330.     }
  1331. }    XSRETURN(argvi);
  1332. }
  1333.  
  1334. XS(_wrap_PDF_setmiterlimit) {
  1335.  
  1336.     PDF * _arg0;
  1337.     float  _arg1;
  1338.     int argvi = 0;
  1339.     dXSARGS ;
  1340.  
  1341.     cv = cv;
  1342.     if ((items < 2) || (items > 2)) 
  1343.         croak("Usage: PDF_setmiterlimit(p,miter);");
  1344.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1345.         croak("Type error in argument 1 of PDF_setmiterlimit. Expected PDFPtr.");
  1346.         XSRETURN(1);
  1347.     }
  1348.     _arg1 = (float ) SvNV(ST(1));
  1349. {
  1350.     try {     PDF_setmiterlimit(_arg0,_arg1);
  1351.  }
  1352.     else {
  1353.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1354.     }
  1355. }    XSRETURN(argvi);
  1356. }
  1357.  
  1358. XS(_wrap_PDF_setlinewidth) {
  1359.  
  1360.     PDF * _arg0;
  1361.     float  _arg1;
  1362.     int argvi = 0;
  1363.     dXSARGS ;
  1364.  
  1365.     cv = cv;
  1366.     if ((items < 2) || (items > 2)) 
  1367.         croak("Usage: PDF_setlinewidth(p,width);");
  1368.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1369.         croak("Type error in argument 1 of PDF_setlinewidth. Expected PDFPtr.");
  1370.         XSRETURN(1);
  1371.     }
  1372.     _arg1 = (float ) SvNV(ST(1));
  1373. {
  1374.     try {     PDF_setlinewidth(_arg0,_arg1);
  1375.  }
  1376.     else {
  1377.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1378.     }
  1379. }    XSRETURN(argvi);
  1380. }
  1381.  
  1382. XS(_wrap_PDF_set_fillrule) {
  1383.  
  1384.     PDF * _arg0;
  1385.     char * _arg1;
  1386.     int argvi = 0;
  1387.     dXSARGS ;
  1388.  
  1389.     cv = cv;
  1390.     if ((items < 2) || (items > 2)) 
  1391.         croak("Usage: PDF_set_fillrule(p,fillrule);");
  1392.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1393.         croak("Type error in argument 1 of PDF_set_fillrule. Expected PDFPtr.");
  1394.         XSRETURN(1);
  1395.     }
  1396.     _arg1 = (char *) SvPV(ST(1),na);
  1397. {
  1398.     try {     PDF_set_fillrule(_arg0,_arg1);
  1399.  }
  1400.     else {
  1401.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1402.     }
  1403. }    XSRETURN(argvi);
  1404. }
  1405.  
  1406. XS(_wrap_PDF_save) {
  1407.  
  1408.     PDF * _arg0;
  1409.     int argvi = 0;
  1410.     dXSARGS ;
  1411.  
  1412.     cv = cv;
  1413.     if ((items < 1) || (items > 1)) 
  1414.         croak("Usage: PDF_save(p);");
  1415.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1416.         croak("Type error in argument 1 of PDF_save. Expected PDFPtr.");
  1417.         XSRETURN(1);
  1418.     }
  1419. {
  1420.     try {     PDF_save(_arg0);
  1421.  }
  1422.     else {
  1423.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1424.     }
  1425. }    XSRETURN(argvi);
  1426. }
  1427.  
  1428. XS(_wrap_PDF_restore) {
  1429.  
  1430.     PDF * _arg0;
  1431.     int argvi = 0;
  1432.     dXSARGS ;
  1433.  
  1434.     cv = cv;
  1435.     if ((items < 1) || (items > 1)) 
  1436.         croak("Usage: PDF_restore(p);");
  1437.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1438.         croak("Type error in argument 1 of PDF_restore. Expected PDFPtr.");
  1439.         XSRETURN(1);
  1440.     }
  1441. {
  1442.     try {     PDF_restore(_arg0);
  1443.  }
  1444.     else {
  1445.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1446.     }
  1447. }    XSRETURN(argvi);
  1448. }
  1449.  
  1450. XS(_wrap_PDF_translate) {
  1451.  
  1452.     PDF * _arg0;
  1453.     float  _arg1;
  1454.     float  _arg2;
  1455.     int argvi = 0;
  1456.     dXSARGS ;
  1457.  
  1458.     cv = cv;
  1459.     if ((items < 3) || (items > 3)) 
  1460.         croak("Usage: PDF_translate(p,tx,ty);");
  1461.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1462.         croak("Type error in argument 1 of PDF_translate. Expected PDFPtr.");
  1463.         XSRETURN(1);
  1464.     }
  1465.     _arg1 = (float ) SvNV(ST(1));
  1466.     _arg2 = (float ) SvNV(ST(2));
  1467. {
  1468.     try {     PDF_translate(_arg0,_arg1,_arg2);
  1469.  }
  1470.     else {
  1471.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1472.     }
  1473. }    XSRETURN(argvi);
  1474. }
  1475.  
  1476. XS(_wrap_PDF_scale) {
  1477.  
  1478.     PDF * _arg0;
  1479.     float  _arg1;
  1480.     float  _arg2;
  1481.     int argvi = 0;
  1482.     dXSARGS ;
  1483.  
  1484.     cv = cv;
  1485.     if ((items < 3) || (items > 3)) 
  1486.         croak("Usage: PDF_scale(p,sx,sy);");
  1487.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1488.         croak("Type error in argument 1 of PDF_scale. Expected PDFPtr.");
  1489.         XSRETURN(1);
  1490.     }
  1491.     _arg1 = (float ) SvNV(ST(1));
  1492.     _arg2 = (float ) SvNV(ST(2));
  1493. {
  1494.     try {     PDF_scale(_arg0,_arg1,_arg2);
  1495.  }
  1496.     else {
  1497.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1498.     }
  1499. }    XSRETURN(argvi);
  1500. }
  1501.  
  1502. XS(_wrap_PDF_rotate) {
  1503.  
  1504.     PDF * _arg0;
  1505.     float  _arg1;
  1506.     int argvi = 0;
  1507.     dXSARGS ;
  1508.  
  1509.     cv = cv;
  1510.     if ((items < 2) || (items > 2)) 
  1511.         croak("Usage: PDF_rotate(p,phi);");
  1512.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1513.         croak("Type error in argument 1 of PDF_rotate. Expected PDFPtr.");
  1514.         XSRETURN(1);
  1515.     }
  1516.     _arg1 = (float ) SvNV(ST(1));
  1517. {
  1518.     try {     PDF_rotate(_arg0,_arg1);
  1519.  }
  1520.     else {
  1521.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1522.     }
  1523. }    XSRETURN(argvi);
  1524. }
  1525.  
  1526. XS(_wrap_PDF_moveto) {
  1527.  
  1528.     PDF * _arg0;
  1529.     float  _arg1;
  1530.     float  _arg2;
  1531.     int argvi = 0;
  1532.     dXSARGS ;
  1533.  
  1534.     cv = cv;
  1535.     if ((items < 3) || (items > 3)) 
  1536.         croak("Usage: PDF_moveto(p,x,y);");
  1537.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1538.         croak("Type error in argument 1 of PDF_moveto. Expected PDFPtr.");
  1539.         XSRETURN(1);
  1540.     }
  1541.     _arg1 = (float ) SvNV(ST(1));
  1542.     _arg2 = (float ) SvNV(ST(2));
  1543. {
  1544.     try {     PDF_moveto(_arg0,_arg1,_arg2);
  1545.  }
  1546.     else {
  1547.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1548.     }
  1549. }    XSRETURN(argvi);
  1550. }
  1551.  
  1552. XS(_wrap_PDF_lineto) {
  1553.  
  1554.     PDF * _arg0;
  1555.     float  _arg1;
  1556.     float  _arg2;
  1557.     int argvi = 0;
  1558.     dXSARGS ;
  1559.  
  1560.     cv = cv;
  1561.     if ((items < 3) || (items > 3)) 
  1562.         croak("Usage: PDF_lineto(p,x,y);");
  1563.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1564.         croak("Type error in argument 1 of PDF_lineto. Expected PDFPtr.");
  1565.         XSRETURN(1);
  1566.     }
  1567.     _arg1 = (float ) SvNV(ST(1));
  1568.     _arg2 = (float ) SvNV(ST(2));
  1569. {
  1570.     try {     PDF_lineto(_arg0,_arg1,_arg2);
  1571.  }
  1572.     else {
  1573.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1574.     }
  1575. }    XSRETURN(argvi);
  1576. }
  1577.  
  1578. XS(_wrap_PDF_curveto) {
  1579.  
  1580.     PDF * _arg0;
  1581.     float  _arg1;
  1582.     float  _arg2;
  1583.     float  _arg3;
  1584.     float  _arg4;
  1585.     float  _arg5;
  1586.     float  _arg6;
  1587.     int argvi = 0;
  1588.     dXSARGS ;
  1589.  
  1590.     cv = cv;
  1591.     if ((items < 7) || (items > 7)) 
  1592.         croak("Usage: PDF_curveto(p,x1,y1,x2,y2,x3,y3);");
  1593.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1594.         croak("Type error in argument 1 of PDF_curveto. Expected PDFPtr.");
  1595.         XSRETURN(1);
  1596.     }
  1597.     _arg1 = (float ) SvNV(ST(1));
  1598.     _arg2 = (float ) SvNV(ST(2));
  1599.     _arg3 = (float ) SvNV(ST(3));
  1600.     _arg4 = (float ) SvNV(ST(4));
  1601.     _arg5 = (float ) SvNV(ST(5));
  1602.     _arg6 = (float ) SvNV(ST(6));
  1603. {
  1604.     try {     PDF_curveto(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6);
  1605.  }
  1606.     else {
  1607.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1608.     }
  1609. }    XSRETURN(argvi);
  1610. }
  1611.  
  1612. XS(_wrap_PDF_circle) {
  1613.  
  1614.     PDF * _arg0;
  1615.     float  _arg1;
  1616.     float  _arg2;
  1617.     float  _arg3;
  1618.     int argvi = 0;
  1619.     dXSARGS ;
  1620.  
  1621.     cv = cv;
  1622.     if ((items < 4) || (items > 4)) 
  1623.         croak("Usage: PDF_circle(p,x,y,r);");
  1624.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1625.         croak("Type error in argument 1 of PDF_circle. Expected PDFPtr.");
  1626.         XSRETURN(1);
  1627.     }
  1628.     _arg1 = (float ) SvNV(ST(1));
  1629.     _arg2 = (float ) SvNV(ST(2));
  1630.     _arg3 = (float ) SvNV(ST(3));
  1631. {
  1632.     try {     PDF_circle(_arg0,_arg1,_arg2,_arg3);
  1633.  }
  1634.     else {
  1635.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1636.     }
  1637. }    XSRETURN(argvi);
  1638. }
  1639.  
  1640. XS(_wrap_PDF_arc) {
  1641.  
  1642.     PDF * _arg0;
  1643.     float  _arg1;
  1644.     float  _arg2;
  1645.     float  _arg3;
  1646.     float  _arg4;
  1647.     float  _arg5;
  1648.     int argvi = 0;
  1649.     dXSARGS ;
  1650.  
  1651.     cv = cv;
  1652.     if ((items < 6) || (items > 6)) 
  1653.         croak("Usage: PDF_arc(p,x,y,r,alpha1,alpha2);");
  1654.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1655.         croak("Type error in argument 1 of PDF_arc. Expected PDFPtr.");
  1656.         XSRETURN(1);
  1657.     }
  1658.     _arg1 = (float ) SvNV(ST(1));
  1659.     _arg2 = (float ) SvNV(ST(2));
  1660.     _arg3 = (float ) SvNV(ST(3));
  1661.     _arg4 = (float ) SvNV(ST(4));
  1662.     _arg5 = (float ) SvNV(ST(5));
  1663. {
  1664.     try {     PDF_arc(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
  1665.  }
  1666.     else {
  1667.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1668.     }
  1669. }    XSRETURN(argvi);
  1670. }
  1671.  
  1672. XS(_wrap_PDF_rect) {
  1673.  
  1674.     PDF * _arg0;
  1675.     float  _arg1;
  1676.     float  _arg2;
  1677.     float  _arg3;
  1678.     float  _arg4;
  1679.     int argvi = 0;
  1680.     dXSARGS ;
  1681.  
  1682.     cv = cv;
  1683.     if ((items < 5) || (items > 5)) 
  1684.         croak("Usage: PDF_rect(p,x,y,width,height);");
  1685.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1686.         croak("Type error in argument 1 of PDF_rect. Expected PDFPtr.");
  1687.         XSRETURN(1);
  1688.     }
  1689.     _arg1 = (float ) SvNV(ST(1));
  1690.     _arg2 = (float ) SvNV(ST(2));
  1691.     _arg3 = (float ) SvNV(ST(3));
  1692.     _arg4 = (float ) SvNV(ST(4));
  1693. {
  1694.     try {     PDF_rect(_arg0,_arg1,_arg2,_arg3,_arg4);
  1695.  }
  1696.     else {
  1697.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1698.     }
  1699. }    XSRETURN(argvi);
  1700. }
  1701.  
  1702. XS(_wrap_PDF_closepath) {
  1703.  
  1704.     PDF * _arg0;
  1705.     int argvi = 0;
  1706.     dXSARGS ;
  1707.  
  1708.     cv = cv;
  1709.     if ((items < 1) || (items > 1)) 
  1710.         croak("Usage: PDF_closepath(p);");
  1711.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1712.         croak("Type error in argument 1 of PDF_closepath. Expected PDFPtr.");
  1713.         XSRETURN(1);
  1714.     }
  1715. {
  1716.     try {     PDF_closepath(_arg0);
  1717.  }
  1718.     else {
  1719.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1720.     }
  1721. }    XSRETURN(argvi);
  1722. }
  1723.  
  1724. XS(_wrap_PDF_stroke) {
  1725.  
  1726.     PDF * _arg0;
  1727.     int argvi = 0;
  1728.     dXSARGS ;
  1729.  
  1730.     cv = cv;
  1731.     if ((items < 1) || (items > 1)) 
  1732.         croak("Usage: PDF_stroke(p);");
  1733.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1734.         croak("Type error in argument 1 of PDF_stroke. Expected PDFPtr.");
  1735.         XSRETURN(1);
  1736.     }
  1737. {
  1738.     try {     PDF_stroke(_arg0);
  1739.  }
  1740.     else {
  1741.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1742.     }
  1743. }    XSRETURN(argvi);
  1744. }
  1745.  
  1746. XS(_wrap_PDF_closepath_stroke) {
  1747.  
  1748.     PDF * _arg0;
  1749.     int argvi = 0;
  1750.     dXSARGS ;
  1751.  
  1752.     cv = cv;
  1753.     if ((items < 1) || (items > 1)) 
  1754.         croak("Usage: PDF_closepath_stroke(p);");
  1755.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1756.         croak("Type error in argument 1 of PDF_closepath_stroke. Expected PDFPtr.");
  1757.         XSRETURN(1);
  1758.     }
  1759. {
  1760.     try {     PDF_closepath_stroke(_arg0);
  1761.  }
  1762.     else {
  1763.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1764.     }
  1765. }    XSRETURN(argvi);
  1766. }
  1767.  
  1768. XS(_wrap_PDF_fill) {
  1769.  
  1770.     PDF * _arg0;
  1771.     int argvi = 0;
  1772.     dXSARGS ;
  1773.  
  1774.     cv = cv;
  1775.     if ((items < 1) || (items > 1)) 
  1776.         croak("Usage: PDF_fill(p);");
  1777.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1778.         croak("Type error in argument 1 of PDF_fill. Expected PDFPtr.");
  1779.         XSRETURN(1);
  1780.     }
  1781. {
  1782.     try {     PDF_fill(_arg0);
  1783.  }
  1784.     else {
  1785.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1786.     }
  1787. }    XSRETURN(argvi);
  1788. }
  1789.  
  1790. XS(_wrap_PDF_fill_stroke) {
  1791.  
  1792.     PDF * _arg0;
  1793.     int argvi = 0;
  1794.     dXSARGS ;
  1795.  
  1796.     cv = cv;
  1797.     if ((items < 1) || (items > 1)) 
  1798.         croak("Usage: PDF_fill_stroke(p);");
  1799.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1800.         croak("Type error in argument 1 of PDF_fill_stroke. Expected PDFPtr.");
  1801.         XSRETURN(1);
  1802.     }
  1803. {
  1804.     try {     PDF_fill_stroke(_arg0);
  1805.  }
  1806.     else {
  1807.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1808.     }
  1809. }    XSRETURN(argvi);
  1810. }
  1811.  
  1812. XS(_wrap_PDF_closepath_fill_stroke) {
  1813.  
  1814.     PDF * _arg0;
  1815.     int argvi = 0;
  1816.     dXSARGS ;
  1817.  
  1818.     cv = cv;
  1819.     if ((items < 1) || (items > 1)) 
  1820.         croak("Usage: PDF_closepath_fill_stroke(p);");
  1821.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1822.         croak("Type error in argument 1 of PDF_closepath_fill_stroke. Expected PDFPtr.");
  1823.         XSRETURN(1);
  1824.     }
  1825. {
  1826.     try {     PDF_closepath_fill_stroke(_arg0);
  1827.  }
  1828.     else {
  1829.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1830.     }
  1831. }    XSRETURN(argvi);
  1832. }
  1833.  
  1834. XS(_wrap_PDF_endpath) {
  1835.  
  1836.     PDF * _arg0;
  1837.     int argvi = 0;
  1838.     dXSARGS ;
  1839.  
  1840.     cv = cv;
  1841.     if ((items < 1) || (items > 1)) 
  1842.         croak("Usage: PDF_endpath(p);");
  1843.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1844.         croak("Type error in argument 1 of PDF_endpath. Expected PDFPtr.");
  1845.         XSRETURN(1);
  1846.     }
  1847. {
  1848.     try {     PDF_endpath(_arg0);
  1849.  }
  1850.     else {
  1851.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1852.     }
  1853. }    XSRETURN(argvi);
  1854. }
  1855.  
  1856. XS(_wrap_PDF_clip) {
  1857.  
  1858.     PDF * _arg0;
  1859.     int argvi = 0;
  1860.     dXSARGS ;
  1861.  
  1862.     cv = cv;
  1863.     if ((items < 1) || (items > 1)) 
  1864.         croak("Usage: PDF_clip(p);");
  1865.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1866.         croak("Type error in argument 1 of PDF_clip. Expected PDFPtr.");
  1867.         XSRETURN(1);
  1868.     }
  1869. {
  1870.     try {     PDF_clip(_arg0);
  1871.  }
  1872.     else {
  1873.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1874.     }
  1875. }    XSRETURN(argvi);
  1876. }
  1877.  
  1878. XS(_wrap_PDF_setgray_fill) {
  1879.  
  1880.     PDF * _arg0;
  1881.     float  _arg1;
  1882.     int argvi = 0;
  1883.     dXSARGS ;
  1884.  
  1885.     cv = cv;
  1886.     if ((items < 2) || (items > 2)) 
  1887.         croak("Usage: PDF_setgray_fill(p,g);");
  1888.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1889.         croak("Type error in argument 1 of PDF_setgray_fill. Expected PDFPtr.");
  1890.         XSRETURN(1);
  1891.     }
  1892.     _arg1 = (float ) SvNV(ST(1));
  1893. {
  1894.     try {     PDF_setgray_fill(_arg0,_arg1);
  1895.  }
  1896.     else {
  1897.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1898.     }
  1899. }    XSRETURN(argvi);
  1900. }
  1901.  
  1902. XS(_wrap_PDF_setgray_stroke) {
  1903.  
  1904.     PDF * _arg0;
  1905.     float  _arg1;
  1906.     int argvi = 0;
  1907.     dXSARGS ;
  1908.  
  1909.     cv = cv;
  1910.     if ((items < 2) || (items > 2)) 
  1911.         croak("Usage: PDF_setgray_stroke(p,g);");
  1912.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1913.         croak("Type error in argument 1 of PDF_setgray_stroke. Expected PDFPtr.");
  1914.         XSRETURN(1);
  1915.     }
  1916.     _arg1 = (float ) SvNV(ST(1));
  1917. {
  1918.     try {     PDF_setgray_stroke(_arg0,_arg1);
  1919.  }
  1920.     else {
  1921.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1922.     }
  1923. }    XSRETURN(argvi);
  1924. }
  1925.  
  1926. XS(_wrap_PDF_setgray) {
  1927.  
  1928.     PDF * _arg0;
  1929.     float  _arg1;
  1930.     int argvi = 0;
  1931.     dXSARGS ;
  1932.  
  1933.     cv = cv;
  1934.     if ((items < 2) || (items > 2)) 
  1935.         croak("Usage: PDF_setgray(p,g);");
  1936.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1937.         croak("Type error in argument 1 of PDF_setgray. Expected PDFPtr.");
  1938.         XSRETURN(1);
  1939.     }
  1940.     _arg1 = (float ) SvNV(ST(1));
  1941. {
  1942.     try {     PDF_setgray(_arg0,_arg1);
  1943.  }
  1944.     else {
  1945.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1946.     }
  1947. }    XSRETURN(argvi);
  1948. }
  1949.  
  1950. XS(_wrap_PDF_setrgbcolor_fill) {
  1951.  
  1952.     PDF * _arg0;
  1953.     float  _arg1;
  1954.     float  _arg2;
  1955.     float  _arg3;
  1956.     int argvi = 0;
  1957.     dXSARGS ;
  1958.  
  1959.     cv = cv;
  1960.     if ((items < 4) || (items > 4)) 
  1961.         croak("Usage: PDF_setrgbcolor_fill(p,red,green,blue);");
  1962.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1963.         croak("Type error in argument 1 of PDF_setrgbcolor_fill. Expected PDFPtr.");
  1964.         XSRETURN(1);
  1965.     }
  1966.     _arg1 = (float ) SvNV(ST(1));
  1967.     _arg2 = (float ) SvNV(ST(2));
  1968.     _arg3 = (float ) SvNV(ST(3));
  1969. {
  1970.     try {     PDF_setrgbcolor_fill(_arg0,_arg1,_arg2,_arg3);
  1971.  }
  1972.     else {
  1973.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  1974.     }
  1975. }    XSRETURN(argvi);
  1976. }
  1977.  
  1978. XS(_wrap_PDF_setrgbcolor_stroke) {
  1979.  
  1980.     PDF * _arg0;
  1981.     float  _arg1;
  1982.     float  _arg2;
  1983.     float  _arg3;
  1984.     int argvi = 0;
  1985.     dXSARGS ;
  1986.  
  1987.     cv = cv;
  1988.     if ((items < 4) || (items > 4)) 
  1989.         croak("Usage: PDF_setrgbcolor_stroke(p,red,green,blue);");
  1990.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  1991.         croak("Type error in argument 1 of PDF_setrgbcolor_stroke. Expected PDFPtr.");
  1992.         XSRETURN(1);
  1993.     }
  1994.     _arg1 = (float ) SvNV(ST(1));
  1995.     _arg2 = (float ) SvNV(ST(2));
  1996.     _arg3 = (float ) SvNV(ST(3));
  1997. {
  1998.     try {     PDF_setrgbcolor_stroke(_arg0,_arg1,_arg2,_arg3);
  1999.  }
  2000.     else {
  2001.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2002.     }
  2003. }    XSRETURN(argvi);
  2004. }
  2005.  
  2006. XS(_wrap_PDF_setrgbcolor) {
  2007.  
  2008.     PDF * _arg0;
  2009.     float  _arg1;
  2010.     float  _arg2;
  2011.     float  _arg3;
  2012.     int argvi = 0;
  2013.     dXSARGS ;
  2014.  
  2015.     cv = cv;
  2016.     if ((items < 4) || (items > 4)) 
  2017.         croak("Usage: PDF_setrgbcolor(p,red,green,blue);");
  2018.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2019.         croak("Type error in argument 1 of PDF_setrgbcolor. Expected PDFPtr.");
  2020.         XSRETURN(1);
  2021.     }
  2022.     _arg1 = (float ) SvNV(ST(1));
  2023.     _arg2 = (float ) SvNV(ST(2));
  2024.     _arg3 = (float ) SvNV(ST(3));
  2025. {
  2026.     try {     PDF_setrgbcolor(_arg0,_arg1,_arg2,_arg3);
  2027.  }
  2028.     else {
  2029.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2030.     }
  2031. }    XSRETURN(argvi);
  2032. }
  2033.  
  2034. XS(_wrap_PDF_get_image_width) {
  2035.  
  2036.     int  _result;
  2037.     PDF * _arg0;
  2038.     int  _arg1;
  2039.     int argvi = 0;
  2040.     dXSARGS ;
  2041.  
  2042.     cv = cv;
  2043.     if ((items < 2) || (items > 2)) 
  2044.         croak("Usage: PDF_get_image_width(p,image);");
  2045.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2046.         croak("Type error in argument 1 of PDF_get_image_width. Expected PDFPtr.");
  2047.         XSRETURN(1);
  2048.     }
  2049.     _arg1 = (int )SvIV(ST(1));
  2050. {
  2051.     try {     _result = (int )PDF_get_image_width(_arg0,_arg1);
  2052.  }
  2053.     else {
  2054.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2055.     }
  2056. }    ST(argvi) = sv_newmortal();
  2057.     sv_setiv(ST(argvi++),(IV) _result);
  2058.     XSRETURN(argvi);
  2059. }
  2060.  
  2061. XS(_wrap_PDF_get_image_height) {
  2062.  
  2063.     int  _result;
  2064.     PDF * _arg0;
  2065.     int  _arg1;
  2066.     int argvi = 0;
  2067.     dXSARGS ;
  2068.  
  2069.     cv = cv;
  2070.     if ((items < 2) || (items > 2)) 
  2071.         croak("Usage: PDF_get_image_height(p,image);");
  2072.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2073.         croak("Type error in argument 1 of PDF_get_image_height. Expected PDFPtr.");
  2074.         XSRETURN(1);
  2075.     }
  2076.     _arg1 = (int )SvIV(ST(1));
  2077. {
  2078.     try {     _result = (int )PDF_get_image_height(_arg0,_arg1);
  2079.  }
  2080.     else {
  2081.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2082.     }
  2083. }    ST(argvi) = sv_newmortal();
  2084.     sv_setiv(ST(argvi++),(IV) _result);
  2085.     XSRETURN(argvi);
  2086. }
  2087.  
  2088. XS(_wrap_PDF_place_image) {
  2089.  
  2090.     PDF * _arg0;
  2091.     int  _arg1;
  2092.     float  _arg2;
  2093.     float  _arg3;
  2094.     float  _arg4;
  2095.     int argvi = 0;
  2096.     dXSARGS ;
  2097.  
  2098.     cv = cv;
  2099.     if ((items < 5) || (items > 5)) 
  2100.         croak("Usage: PDF_place_image(p,image,x,y,scale);");
  2101.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2102.         croak("Type error in argument 1 of PDF_place_image. Expected PDFPtr.");
  2103.         XSRETURN(1);
  2104.     }
  2105.     _arg1 = (int )SvIV(ST(1));
  2106.     _arg2 = (float ) SvNV(ST(2));
  2107.     _arg3 = (float ) SvNV(ST(3));
  2108.     _arg4 = (float ) SvNV(ST(4));
  2109. {
  2110.     try {     PDF_place_image(_arg0,_arg1,_arg2,_arg3,_arg4);
  2111.  }
  2112.     else {
  2113.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2114.     }
  2115. }    XSRETURN(argvi);
  2116. }
  2117.  
  2118. XS(_wrap_PDF_open_image) {
  2119.  
  2120.     int  _result;
  2121.     PDF * _arg0;
  2122.     char * _arg1;
  2123.     char * _arg2;
  2124.     char * _arg3;
  2125.     long  _arg4;
  2126.     int  _arg5;
  2127.     int  _arg6;
  2128.     int  _arg7;
  2129.     int  _arg8;
  2130.     char * _arg9;
  2131.     int argvi = 0;
  2132.     dXSARGS ;
  2133.  
  2134.     cv = cv;
  2135.     if ((items < 10) || (items > 10)) 
  2136.         croak("Usage: PDF_open_image(p,type,source,data,length,width,height,components,bpc,params);");
  2137.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2138.         croak("Type error in argument 1 of PDF_open_image. Expected PDFPtr.");
  2139.         XSRETURN(1);
  2140.     }
  2141.     _arg1 = (char *) SvPV(ST(1),na);
  2142.     _arg2 = (char *) SvPV(ST(2),na);
  2143.     _arg3 = (char *) SvPV(ST(3),na);
  2144.     _arg4 = (long )SvIV(ST(4));
  2145.     _arg5 = (int )SvIV(ST(5));
  2146.     _arg6 = (int )SvIV(ST(6));
  2147.     _arg7 = (int )SvIV(ST(7));
  2148.     _arg8 = (int )SvIV(ST(8));
  2149.     _arg9 = (char *) SvPV(ST(9),na);
  2150. {
  2151.     try {     _result = (int )PDF_open_image(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9);
  2152.  }
  2153.     else {
  2154.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2155.     }
  2156. }    ST(argvi) = sv_newmortal();
  2157.     sv_setiv(ST(argvi++),(IV) _result);
  2158.     XSRETURN(argvi);
  2159. }
  2160.  
  2161. XS(_wrap_PDF_close_image) {
  2162.  
  2163.     PDF * _arg0;
  2164.     int  _arg1;
  2165.     int argvi = 0;
  2166.     dXSARGS ;
  2167.  
  2168.     cv = cv;
  2169.     if ((items < 2) || (items > 2)) 
  2170.         croak("Usage: PDF_close_image(p,image);");
  2171.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2172.         croak("Type error in argument 1 of PDF_close_image. Expected PDFPtr.");
  2173.         XSRETURN(1);
  2174.     }
  2175.     _arg1 = (int )SvIV(ST(1));
  2176. {
  2177.     try {     PDF_close_image(_arg0,_arg1);
  2178.  }
  2179.     else {
  2180.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2181.     }
  2182. }    XSRETURN(argvi);
  2183. }
  2184.  
  2185. XS(_wrap_PDF_open_JPEG) {
  2186.  
  2187.     int  _result;
  2188.     PDF * _arg0;
  2189.     char * _arg1;
  2190.     int argvi = 0;
  2191.     dXSARGS ;
  2192.  
  2193.     cv = cv;
  2194.     if ((items < 2) || (items > 2)) 
  2195.         croak("Usage: PDF_open_JPEG(p,filename);");
  2196.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2197.         croak("Type error in argument 1 of PDF_open_JPEG. Expected PDFPtr.");
  2198.         XSRETURN(1);
  2199.     }
  2200.     _arg1 = (char *) SvPV(ST(1),na);
  2201. {
  2202.     try {     _result = (int )PDF_open_JPEG(_arg0,_arg1);
  2203.  }
  2204.     else {
  2205.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2206.     }
  2207. }    ST(argvi) = sv_newmortal();
  2208.     sv_setiv(ST(argvi++),(IV) _result);
  2209.     XSRETURN(argvi);
  2210. }
  2211.  
  2212. XS(_wrap_PDF_open_TIFF) {
  2213.  
  2214.     int  _result;
  2215.     PDF * _arg0;
  2216.     char * _arg1;
  2217.     int argvi = 0;
  2218.     dXSARGS ;
  2219.  
  2220.     cv = cv;
  2221.     if ((items < 2) || (items > 2)) 
  2222.         croak("Usage: PDF_open_TIFF(p,filename);");
  2223.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2224.         croak("Type error in argument 1 of PDF_open_TIFF. Expected PDFPtr.");
  2225.         XSRETURN(1);
  2226.     }
  2227.     _arg1 = (char *) SvPV(ST(1),na);
  2228. {
  2229.     try {     _result = (int )PDF_open_TIFF(_arg0,_arg1);
  2230.  }
  2231.     else {
  2232.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2233.     }
  2234. }    ST(argvi) = sv_newmortal();
  2235.     sv_setiv(ST(argvi++),(IV) _result);
  2236.     XSRETURN(argvi);
  2237. }
  2238.  
  2239. XS(_wrap_PDF_open_GIF) {
  2240.  
  2241.     int  _result;
  2242.     PDF * _arg0;
  2243.     char * _arg1;
  2244.     int argvi = 0;
  2245.     dXSARGS ;
  2246.  
  2247.     cv = cv;
  2248.     if ((items < 2) || (items > 2)) 
  2249.         croak("Usage: PDF_open_GIF(p,filename);");
  2250.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2251.         croak("Type error in argument 1 of PDF_open_GIF. Expected PDFPtr.");
  2252.         XSRETURN(1);
  2253.     }
  2254.     _arg1 = (char *) SvPV(ST(1),na);
  2255. {
  2256.     try {     _result = (int )PDF_open_GIF(_arg0,_arg1);
  2257.  }
  2258.     else {
  2259.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2260.     }
  2261. }    ST(argvi) = sv_newmortal();
  2262.     sv_setiv(ST(argvi++),(IV) _result);
  2263.     XSRETURN(argvi);
  2264. }
  2265.  
  2266. XS(_wrap_PDF_open_CCITT) {
  2267.  
  2268.     int  _result;
  2269.     PDF * _arg0;
  2270.     char * _arg1;
  2271.     int  _arg2;
  2272.     int  _arg3;
  2273.     int  _arg4;
  2274.     int  _arg5;
  2275.     int  _arg6;
  2276.     int argvi = 0;
  2277.     dXSARGS ;
  2278.  
  2279.     cv = cv;
  2280.     if ((items < 7) || (items > 7)) 
  2281.         croak("Usage: PDF_open_CCITT(p,filename,width,height,BitReverse,K,BlackIs1);");
  2282.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2283.         croak("Type error in argument 1 of PDF_open_CCITT. Expected PDFPtr.");
  2284.         XSRETURN(1);
  2285.     }
  2286.     _arg1 = (char *) SvPV(ST(1),na);
  2287.     _arg2 = (int )SvIV(ST(2));
  2288.     _arg3 = (int )SvIV(ST(3));
  2289.     _arg4 = (int )SvIV(ST(4));
  2290.     _arg5 = (int )SvIV(ST(5));
  2291.     _arg6 = (int )SvIV(ST(6));
  2292. {
  2293.     try {     _result = (int )PDF_open_CCITT(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6);
  2294.  }
  2295.     else {
  2296.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2297.     }
  2298. }    ST(argvi) = sv_newmortal();
  2299.     sv_setiv(ST(argvi++),(IV) _result);
  2300.     XSRETURN(argvi);
  2301. }
  2302.  
  2303. XS(_wrap_PDF_add_bookmark) {
  2304.  
  2305.     int  _result;
  2306.     PDF * _arg0;
  2307.     char * _arg1;
  2308.     int  _arg2;
  2309.     int  _arg3;
  2310.     int argvi = 0;
  2311.     dXSARGS ;
  2312.  
  2313.     cv = cv;
  2314.     if ((items < 4) || (items > 4)) 
  2315.         croak("Usage: PDF_add_bookmark(p,text,parent,open);");
  2316.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2317.         croak("Type error in argument 1 of PDF_add_bookmark. Expected PDFPtr.");
  2318.         XSRETURN(1);
  2319.     }
  2320.     _arg1 = (char *) SvPV(ST(1),na);
  2321.     _arg2 = (int )SvIV(ST(2));
  2322.     _arg3 = (int )SvIV(ST(3));
  2323. {
  2324.     try {     _result = (int )PDF_add_bookmark(_arg0,_arg1,_arg2,_arg3);
  2325.  }
  2326.     else {
  2327.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2328.     }
  2329. }    ST(argvi) = sv_newmortal();
  2330.     sv_setiv(ST(argvi++),(IV) _result);
  2331.     XSRETURN(argvi);
  2332. }
  2333.  
  2334. XS(_wrap_PDF_set_info) {
  2335.  
  2336.     PDF * _arg0;
  2337.     char * _arg1;
  2338.     char * _arg2;
  2339.     int argvi = 0;
  2340.     dXSARGS ;
  2341.  
  2342.     cv = cv;
  2343.     if ((items < 3) || (items > 3)) 
  2344.         croak("Usage: PDF_set_info(p,key,value);");
  2345.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2346.         croak("Type error in argument 1 of PDF_set_info. Expected PDFPtr.");
  2347.         XSRETURN(1);
  2348.     }
  2349.     _arg1 = (char *) SvPV(ST(1),na);
  2350.     _arg2 = (char *) SvPV(ST(2),na);
  2351. {
  2352.     try {     PDF_set_info(_arg0,_arg1,_arg2);
  2353.  }
  2354.     else {
  2355.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2356.     }
  2357. }    XSRETURN(argvi);
  2358. }
  2359.  
  2360. XS(_wrap_PDF_set_transition) {
  2361.  
  2362.     PDF * _arg0;
  2363.     char * _arg1;
  2364.     int argvi = 0;
  2365.     dXSARGS ;
  2366.  
  2367.     cv = cv;
  2368.     if ((items < 2) || (items > 2)) 
  2369.         croak("Usage: PDF_set_transition(p,type);");
  2370.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2371.         croak("Type error in argument 1 of PDF_set_transition. Expected PDFPtr.");
  2372.         XSRETURN(1);
  2373.     }
  2374.     _arg1 = (char *) SvPV(ST(1),na);
  2375. {
  2376.     try {     PDF_set_transition(_arg0,_arg1);
  2377.  }
  2378.     else {
  2379.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2380.     }
  2381. }    XSRETURN(argvi);
  2382. }
  2383.  
  2384. XS(_wrap_PDF_set_duration) {
  2385.  
  2386.     PDF * _arg0;
  2387.     float  _arg1;
  2388.     int argvi = 0;
  2389.     dXSARGS ;
  2390.  
  2391.     cv = cv;
  2392.     if ((items < 2) || (items > 2)) 
  2393.         croak("Usage: PDF_set_duration(p,t);");
  2394.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2395.         croak("Type error in argument 1 of PDF_set_duration. Expected PDFPtr.");
  2396.         XSRETURN(1);
  2397.     }
  2398.     _arg1 = (float ) SvNV(ST(1));
  2399. {
  2400.     try {     PDF_set_duration(_arg0,_arg1);
  2401.  }
  2402.     else {
  2403.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2404.     }
  2405. }    XSRETURN(argvi);
  2406. }
  2407.  
  2408. XS(_wrap_PDF_attach_file) {
  2409.  
  2410.     PDF * _arg0;
  2411.     float  _arg1;
  2412.     float  _arg2;
  2413.     float  _arg3;
  2414.     float  _arg4;
  2415.     char * _arg5;
  2416.     char * _arg6;
  2417.     char * _arg7;
  2418.     char * _arg8;
  2419.     char * _arg9;
  2420.     int argvi = 0;
  2421.     dXSARGS ;
  2422.  
  2423.     cv = cv;
  2424.     if ((items < 10) || (items > 10)) 
  2425.         croak("Usage: PDF_attach_file(p,llx,lly,urx,ury,filename,description,author,mimetype,icon);");
  2426.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2427.         croak("Type error in argument 1 of PDF_attach_file. Expected PDFPtr.");
  2428.         XSRETURN(1);
  2429.     }
  2430.     _arg1 = (float ) SvNV(ST(1));
  2431.     _arg2 = (float ) SvNV(ST(2));
  2432.     _arg3 = (float ) SvNV(ST(3));
  2433.     _arg4 = (float ) SvNV(ST(4));
  2434.     _arg5 = (char *) SvPV(ST(5),na);
  2435.     _arg6 = (char *) SvPV(ST(6),na);
  2436.     _arg7 = (char *) SvPV(ST(7),na);
  2437.     _arg8 = (char *) SvPV(ST(8),na);
  2438.     _arg9 = (char *) SvPV(ST(9),na);
  2439. {
  2440.     try {     PDF_attach_file(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9);
  2441.  }
  2442.     else {
  2443.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2444.     }
  2445. }    XSRETURN(argvi);
  2446. }
  2447.  
  2448. XS(_wrap_PDF_add_note) {
  2449.  
  2450.     PDF * _arg0;
  2451.     float  _arg1;
  2452.     float  _arg2;
  2453.     float  _arg3;
  2454.     float  _arg4;
  2455.     char * _arg5;
  2456.     char * _arg6;
  2457.     char * _arg7;
  2458.     int  _arg8;
  2459.     int argvi = 0;
  2460.     dXSARGS ;
  2461.  
  2462.     cv = cv;
  2463.     if ((items < 9) || (items > 9)) 
  2464.         croak("Usage: PDF_add_note(p,llx,lly,urx,ury,contents,title,icon,open);");
  2465.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2466.         croak("Type error in argument 1 of PDF_add_note. Expected PDFPtr.");
  2467.         XSRETURN(1);
  2468.     }
  2469.     _arg1 = (float ) SvNV(ST(1));
  2470.     _arg2 = (float ) SvNV(ST(2));
  2471.     _arg3 = (float ) SvNV(ST(3));
  2472.     _arg4 = (float ) SvNV(ST(4));
  2473.     _arg5 = (char *) SvPV(ST(5),na);
  2474.     _arg6 = (char *) SvPV(ST(6),na);
  2475.     _arg7 = (char *) SvPV(ST(7),na);
  2476.     _arg8 = (int )SvIV(ST(8));
  2477. {
  2478.     try {     PDF_add_note(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8);
  2479.  }
  2480.     else {
  2481.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2482.     }
  2483. }    XSRETURN(argvi);
  2484. }
  2485.  
  2486. XS(_wrap_PDF_add_pdflink) {
  2487.  
  2488.     PDF * _arg0;
  2489.     float  _arg1;
  2490.     float  _arg2;
  2491.     float  _arg3;
  2492.     float  _arg4;
  2493.     char * _arg5;
  2494.     int  _arg6;
  2495.     char * _arg7;
  2496.     int argvi = 0;
  2497.     dXSARGS ;
  2498.  
  2499.     cv = cv;
  2500.     if ((items < 8) || (items > 8)) 
  2501.         croak("Usage: PDF_add_pdflink(p,llx,lly,urx,ury,filename,page,dest);");
  2502.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2503.         croak("Type error in argument 1 of PDF_add_pdflink. Expected PDFPtr.");
  2504.         XSRETURN(1);
  2505.     }
  2506.     _arg1 = (float ) SvNV(ST(1));
  2507.     _arg2 = (float ) SvNV(ST(2));
  2508.     _arg3 = (float ) SvNV(ST(3));
  2509.     _arg4 = (float ) SvNV(ST(4));
  2510.     _arg5 = (char *) SvPV(ST(5),na);
  2511.     _arg6 = (int )SvIV(ST(6));
  2512.     _arg7 = (char *) SvPV(ST(7),na);
  2513. {
  2514.     try {     PDF_add_pdflink(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7);
  2515.  }
  2516.     else {
  2517.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2518.     }
  2519. }    XSRETURN(argvi);
  2520. }
  2521.  
  2522. XS(_wrap_PDF_add_launchlink) {
  2523.  
  2524.     PDF * _arg0;
  2525.     float  _arg1;
  2526.     float  _arg2;
  2527.     float  _arg3;
  2528.     float  _arg4;
  2529.     char * _arg5;
  2530.     int argvi = 0;
  2531.     dXSARGS ;
  2532.  
  2533.     cv = cv;
  2534.     if ((items < 6) || (items > 6)) 
  2535.         croak("Usage: PDF_add_launchlink(p,llx,lly,urx,ury,filename);");
  2536.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2537.         croak("Type error in argument 1 of PDF_add_launchlink. Expected PDFPtr.");
  2538.         XSRETURN(1);
  2539.     }
  2540.     _arg1 = (float ) SvNV(ST(1));
  2541.     _arg2 = (float ) SvNV(ST(2));
  2542.     _arg3 = (float ) SvNV(ST(3));
  2543.     _arg4 = (float ) SvNV(ST(4));
  2544.     _arg5 = (char *) SvPV(ST(5),na);
  2545. {
  2546.     try {     PDF_add_launchlink(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
  2547.  }
  2548.     else {
  2549.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2550.     }
  2551. }    XSRETURN(argvi);
  2552. }
  2553.  
  2554. XS(_wrap_PDF_add_locallink) {
  2555.  
  2556.     PDF * _arg0;
  2557.     float  _arg1;
  2558.     float  _arg2;
  2559.     float  _arg3;
  2560.     float  _arg4;
  2561.     int  _arg5;
  2562.     char * _arg6;
  2563.     int argvi = 0;
  2564.     dXSARGS ;
  2565.  
  2566.     cv = cv;
  2567.     if ((items < 7) || (items > 7)) 
  2568.         croak("Usage: PDF_add_locallink(p,llx,lly,urx,ury,page,dest);");
  2569.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2570.         croak("Type error in argument 1 of PDF_add_locallink. Expected PDFPtr.");
  2571.         XSRETURN(1);
  2572.     }
  2573.     _arg1 = (float ) SvNV(ST(1));
  2574.     _arg2 = (float ) SvNV(ST(2));
  2575.     _arg3 = (float ) SvNV(ST(3));
  2576.     _arg4 = (float ) SvNV(ST(4));
  2577.     _arg5 = (int )SvIV(ST(5));
  2578.     _arg6 = (char *) SvPV(ST(6),na);
  2579. {
  2580.     try {     PDF_add_locallink(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6);
  2581.  }
  2582.     else {
  2583.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2584.     }
  2585. }    XSRETURN(argvi);
  2586. }
  2587.  
  2588. XS(_wrap_PDF_add_weblink) {
  2589.  
  2590.     PDF * _arg0;
  2591.     float  _arg1;
  2592.     float  _arg2;
  2593.     float  _arg3;
  2594.     float  _arg4;
  2595.     char * _arg5;
  2596.     int argvi = 0;
  2597.     dXSARGS ;
  2598.  
  2599.     cv = cv;
  2600.     if ((items < 6) || (items > 6)) 
  2601.         croak("Usage: PDF_add_weblink(p,llx,lly,urx,ury,url);");
  2602.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2603.         croak("Type error in argument 1 of PDF_add_weblink. Expected PDFPtr.");
  2604.         XSRETURN(1);
  2605.     }
  2606.     _arg1 = (float ) SvNV(ST(1));
  2607.     _arg2 = (float ) SvNV(ST(2));
  2608.     _arg3 = (float ) SvNV(ST(3));
  2609.     _arg4 = (float ) SvNV(ST(4));
  2610.     _arg5 = (char *) SvPV(ST(5),na);
  2611. {
  2612.     try {     PDF_add_weblink(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
  2613.  }
  2614.     else {
  2615.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2616.     }
  2617. }    XSRETURN(argvi);
  2618. }
  2619.  
  2620. XS(_wrap_PDF_set_border_style) {
  2621.  
  2622.     PDF * _arg0;
  2623.     char * _arg1;
  2624.     float  _arg2;
  2625.     int argvi = 0;
  2626.     dXSARGS ;
  2627.  
  2628.     cv = cv;
  2629.     if ((items < 3) || (items > 3)) 
  2630.         croak("Usage: PDF_set_border_style(p,style,width);");
  2631.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2632.         croak("Type error in argument 1 of PDF_set_border_style. Expected PDFPtr.");
  2633.         XSRETURN(1);
  2634.     }
  2635.     _arg1 = (char *) SvPV(ST(1),na);
  2636.     _arg2 = (float ) SvNV(ST(2));
  2637. {
  2638.     try {     PDF_set_border_style(_arg0,_arg1,_arg2);
  2639.  }
  2640.     else {
  2641.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2642.     }
  2643. }    XSRETURN(argvi);
  2644. }
  2645.  
  2646. XS(_wrap_PDF_set_border_color) {
  2647.  
  2648.     PDF * _arg0;
  2649.     float  _arg1;
  2650.     float  _arg2;
  2651.     float  _arg3;
  2652.     int argvi = 0;
  2653.     dXSARGS ;
  2654.  
  2655.     cv = cv;
  2656.     if ((items < 4) || (items > 4)) 
  2657.         croak("Usage: PDF_set_border_color(p,red,green,blue);");
  2658.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2659.         croak("Type error in argument 1 of PDF_set_border_color. Expected PDFPtr.");
  2660.         XSRETURN(1);
  2661.     }
  2662.     _arg1 = (float ) SvNV(ST(1));
  2663.     _arg2 = (float ) SvNV(ST(2));
  2664.     _arg3 = (float ) SvNV(ST(3));
  2665. {
  2666.     try {     PDF_set_border_color(_arg0,_arg1,_arg2,_arg3);
  2667.  }
  2668.     else {
  2669.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2670.     }
  2671. }    XSRETURN(argvi);
  2672. }
  2673.  
  2674. XS(_wrap_PDF_set_border_dash) {
  2675.  
  2676.     PDF * _arg0;
  2677.     float  _arg1;
  2678.     float  _arg2;
  2679.     int argvi = 0;
  2680.     dXSARGS ;
  2681.  
  2682.     cv = cv;
  2683.     if ((items < 3) || (items > 3)) 
  2684.         croak("Usage: PDF_set_border_dash(p,w,b);");
  2685.     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"PDFPtr")) {
  2686.         croak("Type error in argument 1 of PDF_set_border_dash. Expected PDFPtr.");
  2687.         XSRETURN(1);
  2688.     }
  2689.     _arg1 = (float ) SvNV(ST(1));
  2690.     _arg2 = (float ) SvNV(ST(2));
  2691. {
  2692.     try {     PDF_set_border_dash(_arg0,_arg1,_arg2);
  2693.  }
  2694.     else {
  2695.     SWIG_exception(pdf_swig_exceptions[exception_status], error_message);
  2696.     }
  2697. }    XSRETURN(argvi);
  2698. }
  2699.  
  2700. XS(_wrap_perl5_pdflib_var_init) {
  2701.     dXSARGS;
  2702.     SV *sv;
  2703.     cv = cv; items = items;
  2704.     XSRETURN(1);
  2705. }
  2706. #ifdef __cplusplus
  2707. extern "C"
  2708. #endif
  2709. XS(boot_pdflib) {
  2710.      dXSARGS;
  2711.      char *file = __FILE__;
  2712.      cv = cv; items = items;
  2713.      newXS("pdflibc::var_pdflib_init", _wrap_perl5_pdflib_var_init, file);
  2714.  
  2715.     /* Boot the PDFlib core */
  2716.     PDF_boot();
  2717.      newXS("pdflibc::PDF_boot", _wrap_PDF_boot, file);
  2718.      newXS("pdflibc::PDF_shutdown", _wrap_PDF_shutdown, file);
  2719.      newXS("pdflibc::PDF_new", _wrap_PDF_new, file);
  2720.      newXS("pdflibc::PDF_delete", _wrap_PDF_delete, file);
  2721.      newXS("pdflibc::PDF_open_file", _wrap_PDF_open_file, file);
  2722.      newXS("pdflibc::PDF_close", _wrap_PDF_close, file);
  2723.      newXS("pdflibc::PDF_begin_page", _wrap_PDF_begin_page, file);
  2724.      newXS("pdflibc::PDF_end_page", _wrap_PDF_end_page, file);
  2725.      newXS("pdflibc::PDF_set_parameter", _wrap_PDF_set_parameter, file);
  2726.      newXS("pdflibc::PDF_findfont", _wrap_PDF_findfont, file);
  2727.      newXS("pdflibc::PDF_setfont", _wrap_PDF_setfont, file);
  2728.      newXS("pdflibc::PDF_set_font", _wrap_PDF_set_font, file);
  2729.      newXS("pdflibc::PDF_get_fontname", _wrap_PDF_get_fontname, file);
  2730.      newXS("pdflibc::PDF_get_fontsize", _wrap_PDF_get_fontsize, file);
  2731.      newXS("pdflibc::PDF_get_font", _wrap_PDF_get_font, file);
  2732.      newXS("pdflibc::PDF_show", _wrap_PDF_show, file);
  2733.      newXS("pdflibc::PDF_show_xy", _wrap_PDF_show_xy, file);
  2734.      newXS("pdflibc::PDF_continue_text", _wrap_PDF_continue_text, file);
  2735.      newXS("pdflibc::PDF_set_leading", _wrap_PDF_set_leading, file);
  2736.      newXS("pdflibc::PDF_set_text_rise", _wrap_PDF_set_text_rise, file);
  2737.      newXS("pdflibc::PDF_set_horiz_scaling", _wrap_PDF_set_horiz_scaling, file);
  2738.      newXS("pdflibc::PDF_set_text_rendering", _wrap_PDF_set_text_rendering, file);
  2739.      newXS("pdflibc::PDF_set_text_matrix", _wrap_PDF_set_text_matrix, file);
  2740.      newXS("pdflibc::PDF_set_text_pos", _wrap_PDF_set_text_pos, file);
  2741.      newXS("pdflibc::PDF_set_char_spacing", _wrap_PDF_set_char_spacing, file);
  2742.      newXS("pdflibc::PDF_set_word_spacing", _wrap_PDF_set_word_spacing, file);
  2743.      newXS("pdflibc::PDF_stringwidth", _wrap_PDF_stringwidth, file);
  2744.      newXS("pdflibc::PDF_setdash", _wrap_PDF_setdash, file);
  2745.      newXS("pdflibc::PDF_setpolydash", _wrap_PDF_setpolydash, file);
  2746.      newXS("pdflibc::PDF_setflat", _wrap_PDF_setflat, file);
  2747.      newXS("pdflibc::PDF_setlinejoin", _wrap_PDF_setlinejoin, file);
  2748.      newXS("pdflibc::PDF_setlinecap", _wrap_PDF_setlinecap, file);
  2749.      newXS("pdflibc::PDF_setmiterlimit", _wrap_PDF_setmiterlimit, file);
  2750.      newXS("pdflibc::PDF_setlinewidth", _wrap_PDF_setlinewidth, file);
  2751.      newXS("pdflibc::PDF_set_fillrule", _wrap_PDF_set_fillrule, file);
  2752.      newXS("pdflibc::PDF_save", _wrap_PDF_save, file);
  2753.      newXS("pdflibc::PDF_restore", _wrap_PDF_restore, file);
  2754.      newXS("pdflibc::PDF_translate", _wrap_PDF_translate, file);
  2755.      newXS("pdflibc::PDF_scale", _wrap_PDF_scale, file);
  2756.      newXS("pdflibc::PDF_rotate", _wrap_PDF_rotate, file);
  2757.      newXS("pdflibc::PDF_moveto", _wrap_PDF_moveto, file);
  2758.      newXS("pdflibc::PDF_lineto", _wrap_PDF_lineto, file);
  2759.      newXS("pdflibc::PDF_curveto", _wrap_PDF_curveto, file);
  2760.      newXS("pdflibc::PDF_circle", _wrap_PDF_circle, file);
  2761.      newXS("pdflibc::PDF_arc", _wrap_PDF_arc, file);
  2762.      newXS("pdflibc::PDF_rect", _wrap_PDF_rect, file);
  2763.      newXS("pdflibc::PDF_closepath", _wrap_PDF_closepath, file);
  2764.      newXS("pdflibc::PDF_stroke", _wrap_PDF_stroke, file);
  2765.      newXS("pdflibc::PDF_closepath_stroke", _wrap_PDF_closepath_stroke, file);
  2766.      newXS("pdflibc::PDF_fill", _wrap_PDF_fill, file);
  2767.      newXS("pdflibc::PDF_fill_stroke", _wrap_PDF_fill_stroke, file);
  2768.      newXS("pdflibc::PDF_closepath_fill_stroke", _wrap_PDF_closepath_fill_stroke, file);
  2769.      newXS("pdflibc::PDF_endpath", _wrap_PDF_endpath, file);
  2770.      newXS("pdflibc::PDF_clip", _wrap_PDF_clip, file);
  2771.      newXS("pdflibc::PDF_setgray_fill", _wrap_PDF_setgray_fill, file);
  2772.      newXS("pdflibc::PDF_setgray_stroke", _wrap_PDF_setgray_stroke, file);
  2773.      newXS("pdflibc::PDF_setgray", _wrap_PDF_setgray, file);
  2774.      newXS("pdflibc::PDF_setrgbcolor_fill", _wrap_PDF_setrgbcolor_fill, file);
  2775.      newXS("pdflibc::PDF_setrgbcolor_stroke", _wrap_PDF_setrgbcolor_stroke, file);
  2776.      newXS("pdflibc::PDF_setrgbcolor", _wrap_PDF_setrgbcolor, file);
  2777.      newXS("pdflibc::PDF_get_image_width", _wrap_PDF_get_image_width, file);
  2778.      newXS("pdflibc::PDF_get_image_height", _wrap_PDF_get_image_height, file);
  2779.      newXS("pdflibc::PDF_place_image", _wrap_PDF_place_image, file);
  2780.      newXS("pdflibc::PDF_open_image", _wrap_PDF_open_image, file);
  2781.      newXS("pdflibc::PDF_close_image", _wrap_PDF_close_image, file);
  2782.      newXS("pdflibc::PDF_open_JPEG", _wrap_PDF_open_JPEG, file);
  2783.      newXS("pdflibc::PDF_open_TIFF", _wrap_PDF_open_TIFF, file);
  2784.      newXS("pdflibc::PDF_open_GIF", _wrap_PDF_open_GIF, file);
  2785.      newXS("pdflibc::PDF_open_CCITT", _wrap_PDF_open_CCITT, file);
  2786.      newXS("pdflibc::PDF_add_bookmark", _wrap_PDF_add_bookmark, file);
  2787.      newXS("pdflibc::PDF_set_info", _wrap_PDF_set_info, file);
  2788.      newXS("pdflibc::PDF_set_transition", _wrap_PDF_set_transition, file);
  2789.      newXS("pdflibc::PDF_set_duration", _wrap_PDF_set_duration, file);
  2790.      newXS("pdflibc::PDF_attach_file", _wrap_PDF_attach_file, file);
  2791.      newXS("pdflibc::PDF_add_note", _wrap_PDF_add_note, file);
  2792.      newXS("pdflibc::PDF_add_pdflink", _wrap_PDF_add_pdflink, file);
  2793.      newXS("pdflibc::PDF_add_launchlink", _wrap_PDF_add_launchlink, file);
  2794.      newXS("pdflibc::PDF_add_locallink", _wrap_PDF_add_locallink, file);
  2795.      newXS("pdflibc::PDF_add_weblink", _wrap_PDF_add_weblink, file);
  2796.      newXS("pdflibc::PDF_set_border_style", _wrap_PDF_set_border_style, file);
  2797.      newXS("pdflibc::PDF_set_border_color", _wrap_PDF_set_border_color, file);
  2798.      newXS("pdflibc::PDF_set_border_dash", _wrap_PDF_set_border_dash, file);
  2799. /*
  2800.  * These are the pointer type-equivalency mappings. 
  2801.  * (Used by the SWIG pointer type-checker).
  2802.  */
  2803.      SWIG_RegisterMapping("unsigned short","short",0);
  2804.      SWIG_RegisterMapping("PDF","struct PDF_s",0);
  2805.      SWIG_RegisterMapping("long","unsigned long",0);
  2806.      SWIG_RegisterMapping("long","signed long",0);
  2807.      SWIG_RegisterMapping("signed short","short",0);
  2808.      SWIG_RegisterMapping("signed int","int",0);
  2809.      SWIG_RegisterMapping("short","unsigned short",0);
  2810.      SWIG_RegisterMapping("short","signed short",0);
  2811.      SWIG_RegisterMapping("unsigned long","long",0);
  2812.      SWIG_RegisterMapping("int","unsigned int",0);
  2813.      SWIG_RegisterMapping("int","signed int",0);
  2814.      SWIG_RegisterMapping("unsigned int","int",0);
  2815.      SWIG_RegisterMapping("struct PDF_s","PDF",0);
  2816.      SWIG_RegisterMapping("signed long","long",0);
  2817.      ST(0) = &sv_yes;
  2818.      XSRETURN(1);
  2819. }
  2820.